rtf 0.1.0 → 0.3.0

data/CHANGES

@@ -0,0 +1,5 @@
+== CHANGES
+
+0.3.0
+  * Resolve problems on Ruby 1.9.1 with ImageNode#read_source. Peter uses IO#getc, which returns a String on Ruby 1.9.1, not a Integer, so I replaced with getbyte. [clbustos]
+  * Deleted duplicated definition of ImageNode#style= with attr_writer and def. [clbustos]

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Peter Wood
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/{doc/README → README.rdoc}

@@ -1,4 +1,4 @@
-== Ruby Rich Text Format (RTF) Library 0.1.0
+== 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
 is to ease the complexity involved in assembling RTF documents although some
@@ -174,4 +174,12 @@ There you have it. You've been given a quick overview of the basics of using
 the library. For more information consult the HTML based API documentation that
 is installed with the library gem (if you're reading this you may already be
 looking at this documentation). Another source of information is the examples
-directory, so check that out too.
+directory, so check that out too.
+
+CONTRIBUTORS
+
+Claudio Bustos
+Chris O'Sullivan
+
+COPYRIGHT
+Copyright (c) 2009-2011 Peter Wood. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "rtf"
+    s.summary = 'Ruby library to create rich text format documents.'
+    s.email = "paw220470@yahoo.ie"
+    s.homepage = "http://github.com/thechrisoshow/rtf"
+    s.description = 'Ruby RTF is a library that can be used to create '\
+                    'rich text format (RTF) documents. RTF is a text '\
+                    'based standard for laying out document content.'
+    s.authors = ["Peter Wood"]
+    s.files = FileList["[A-Z]*", "{examples,lib,test}/**/*"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'ruby-rtf'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('[A-Z]*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib' << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.libs << 'test'
+    t.test_files = FileList['test/**/*_test.rb']
+    t.verbose = true
+  end
+rescue LoadError
+  puts "RCov is not available. In order to run rcov, you must: sudo gem install rcov"
+end
+
+task :default => :test

data/VERSION.yml

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

data/examples/example03.rb

@@ -32,9 +32,9 @@ end
 
 document.paragraph(styles['PS_NORMAL']) do |p1|
    p1 << 'This document is automatically generated using the RTF Ruby '
-   p1 << 'library by Peter Wood. This serves as an example of what can '
-   p1 << 'be achieved in document creation via the library. The source '
-   p1 << 'code that was used to generate it is listed below...'
+   p1 << 'library. This serves as an example of what can be achieved '
+   p1 << 'in document creation via the library. The source code that '
+   p1 << 'was used to generate it is listed below...'
 end
 
 document.paragraph(styles['PS_INDENTED']) do |p1|
@@ -60,7 +60,7 @@ end
 document.paragraph(styles['PS_NORMAL']) do |p1|
    p1 << "This example shows the creation of a new document and the "
    p1 << "of textual content to it. The example also provides examples "
-   p1 << "of using block scope to delimit style scope (lines 35-40)."
+   p1 << "of using block scope to delimit style scope (lines 40-51)."
 end
 
 File.open('example03.rtf', 'w') {|file| file.write(document.to_rtf)}

data/examples/example04.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rtf'
+
+include RTF
+
+IMAGE_FILE = 'rubyrtf.png'
+
+begin
+   document = Document.new(Font.new(Font::ROMAN, 'Times New Roman'))
+
+   # Add some text to the document and then add the scaled image.
+   document.paragraph do |p|
+      p << "This is a simple document that attempts to demonstrate the use "
+      p << "of images in a document. A simple image should appear in the page "
+      p << "header above, on the right hand side. The same image, scaled to "
+      p << "four times its normal size, should appear below this text."
+      p.line_break
+   end
+
+   # Add the scaled image.
+   image = document.image(IMAGE_FILE)
+   image.x_scaling = 400
+   image.y_scaling = 400
+
+   # Add some follow up text.
+   document.paragraph do |p|
+      p.line_break
+      p << "Due to the way images are stored in RTF documents, adding images "
+      p << "to a document can result in the document file becoming very large. "
+      p << "The Ruby RTF library supports the addition of images in the PNG, "
+      p << "JPEG and Windows device independent bitmap formats. A compressed "
+      p << "image format (like PNG or JPEG) is preferrable to the plain bitmap "
+      p << "format as this will result in a smaller document file."
+   end
+
+   # Add a header to the document.
+   style  = ParagraphStyle.new
+   style.justification = ParagraphStyle::RIGHT_JUSTIFY
+   header = HeaderNode.new(document)
+   header.paragraph(style) {|n| n.image(IMAGE_FILE)}
+   document.header = header
+
+   # Write the document to a file.
+   File.open('example04.rtf', 'w') {|file| file.write(document.to_rtf)}
+rescue => error
+   puts "ERROR: #{error.message}"
+   error.backtrace.each {|step| puts "   #{step}"}
+end

data/lib/rtf/information.rb

@@ -1,8 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'stringio'
-require 'parsedate'
-
+require 'date'
 module RTF
    # This class represents an information group for a RTF document.
    class Information
@@ -56,7 +55,7 @@ module RTF
          if setting.instance_of?(Time)
             @created = setting
          else
-            datetime = ParseDate::parsedate(setting.to_s)
+           datetime = Date._parse(setting.to_s).values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :wday)
             if datetime == nil
                RTFError.fire("Invalid document creation date/time information "\
                              "specified.")

data/lib/rtf/node.rb

@@ -63,11 +63,8 @@ module RTF
    # This class represents a specialisation of the Node class to refer to a Node
    # that simply contains text.
    class TextNode < Node
-      # Attribute accessor.
-      attr_reader :text
-
-      # Attribute mutator.
-      attr_writer :text
+     # Actual text
+      attr_accessor :text
 
       # This is the constructor for the TextNode class.
       #
@@ -131,11 +128,8 @@ module RTF
    class ContainerNode < Node
       include Enumerable
 
-      # Attribute accessor.
-      attr_reader :children
-
-      # Attribute mutator.
-      attr_writer :children
+      # Children elements of the node
+      attr_accessor :children
 
       # This is the constructor for the ContainerNode class.
       #
@@ -208,11 +202,14 @@ module RTF
    # is concrete enough to be used on its own but will also be used as the
    # base class for some specific command node types.
    class CommandNode < ContainerNode
-      # Attribute accessor.
-      attr_reader :prefix, :suffix, :split
-
-      # Attribute mutator.
-      attr_writer :prefix, :suffix, :split
+      # String containing the prefix text for the command
+      attr_accessor :prefix
+      # String containing the suffix text for the command
+      attr_accessor :suffix
+      # 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
+      attr_accessor :split
 
       # This is the constructor for the CommandNode class.
       #
@@ -306,6 +303,19 @@ module RTF
          end
       end
 
+      # This method inserts a new image at the current position in a node.
+      #
+      # ==== Parameters
+      # source::  Either a string containing the path and name of a file or a
+      #           File object for the image file to be inserted.
+      #
+      # ==== Exceptions
+      # RTFError::  Generated whenever an invalid or inaccessible file is
+      #             specified or the image file type is not supported.
+      def image(source)
+         self.store(ImageNode.new(self, source, root.get_id))
+      end
+
       # This method provides a short cut means for applying multiple styles via
       # single command node. The method accepts a block that will be passed a
       # reference to the node created. Once the block is complete the new node
@@ -509,12 +519,9 @@ module RTF
    # specialised container nodes that contain only TableRowNodes and have their
    # size specified when they are created an cannot be resized after that.
    class TableNode < ContainerNode
-      # Attribute accessor.
-      attr_reader :cell_margin
-
-      # Attribute mutator.
-      attr_writer :cell_margin
-
+      # Cell margin. Default to 100
+      attr_accessor :cell_margin
+      
       # This is a constructor for the TableNode class.
       #
       # ==== Parameters
@@ -523,12 +530,22 @@ module RTF
       # columns::  The number of columns in the table.
       # *widths::  One or more integers specifying the widths of the table
       #            columns.
-      def initialize(parent, rows, columns, *widths)
+      def initialize(parent, *args, &block)
+        if args.size>=2
+         rows=args.shift
+         columns=args.shift
+         widths=args
          super(parent) do
             entries = []
             rows.times {entries.push(TableRowNode.new(self, columns, *widths))}
             entries
          end
+        
+        elsif block
+          block.arity<1 ? self.instance_eval(&block) : block.call(self)
+        else
+          raise "You should use 0 or >2 args"
+        end
          @cell_margin = 100
       end
 
@@ -656,7 +673,7 @@ module RTF
          end
       end
 
-      # Attrobute accessors
+      # Attribute accessors
       def length
          entries.size
       end
@@ -732,13 +749,11 @@ module RTF
    class TableCellNode < CommandNode
       # A definition for the default width for the cell.
       DEFAULT_WIDTH                              = 300
-
+      # Width of cell
+      attr_accessor :width
       # Attribute accessor.
-      attr_reader :width, :shading_colour, :style
-
-      # Attribute mutator.
-      attr_writer :width, :style
-
+      attr_reader :shading_colour, :style
+      
       # This is the constructor for the TableCellNode class.
       #
       # ==== Parameters
@@ -1058,6 +1073,248 @@ module RTF
    end # End of the FooterNode class.
 
 
+   # This class represents an image within a RTF document. Currently only the
+   # PNG, JPEG and Windows Bitmap formats are supported. Efforts are made to
+   # identify the file type but these are not guaranteed to work.
+   class ImageNode < Node
+      # A definition for an image type constant.
+      PNG                                        = :pngblip
+
+      # A definition for an image type constant.
+      JPEG                                       = :jpegblip
+
+      # A definition for an image type constant.
+      BITMAP                                     = :dibitmap0
+
+      # A definition for an architecture endian constant.
+      LITTLE_ENDIAN                              = :little
+
+      # A definition for an architecture endian constant.
+      BIG_ENDIAN                                 = :big
+
+      # Attribute accessor.
+      attr_reader :x_scaling, :y_scaling, :top_crop, :right_crop, :bottom_crop,
+                  :left_crop, :width, :height
+
+      # Attribute mutator.
+      attr_writer :x_scaling, :y_scaling, :top_crop, :right_crop, :bottom_crop,
+                  :left_crop
+
+
+      # This is the constructor for the ImageNode class.
+      #
+      # ==== Parameters
+      # parent::  A reference to the node that owns the new image node.
+      # source::  A reference to the image source. This must be a String or a
+      #           File.
+      # id::      The unique identifier for the image node.
+      #
+      # ==== Exceptions
+      # RTFError::  Generated whenever the image specified is not recognised as
+      #             a supported image type, something other than a String or
+      #             File or IO is passed as the source parameter or if the
+      #             specified source does not exist or cannot be accessed.
+      def initialize(parent, source, id)
+         super(parent)
+         @source = nil
+         @id     = id
+         @read   = []
+         @type   = nil
+         @x_scaling = @y_scaling = nil
+         @top_crop = @right_crop = @bottom_crop = @left_crop = nil
+         @width = @height = nil
+
+         # Check what we were given.
+         src = source
+         src.binmode if src.instance_of?(File)
+         src = File.new(source, 'rb') if source.instance_of?(String)
+         if src.instance_of?(File)
+            # Check the files existence and accessibility.
+            if !File.exist?(src.path)
+               RTFError.fire("Unable to find the #{File.basename(source)} file.")
+            end
+            if !File.readable?(src.path)
+               RTFError.fire("Access to the #{File.basename(source)} file denied.")
+            end
+            @source = src
+         else
+            RTFError.fire("Unrecognised source specified for ImageNode.")
+         end
+
+         @type = get_file_type(src)
+         if @type == nil
+            RTFError.fire("The #{File.basename(source)} file contains an "\
+                          "unknown or unsupported image type.")
+         end
+
+         @width, @height = get_dimensions
+      end
+
+      # This method attempts to determine the image type associated with a
+      # file, returning nil if it fails to make the determination.
+      #
+      # ==== Parameters
+      # file::  A reference to the file to check for image type.
+      def get_file_type(file)
+         type = nil
+
+         # Check if the file is a JPEG.
+         read_source(2)
+
+         if @read[0,2] == [255, 216]
+            type = JPEG
+         else
+            # Check if it's a PNG.
+            read_source(6)
+            if @read[0,8] == [137, 80, 78, 71, 13, 10, 26, 10]
+               type = PNG
+            else
+               # Check if its a bitmap.
+               if @read[0,2] == [66, 77]
+                  size = to_integer(@read[2,4])
+                  type = BITMAP if size == File.size(file.path)
+               end
+            end
+         end
+
+         type
+      end
+
+      # This method generates the RTF for an ImageNode object.
+      def to_rtf
+         text  = StringIO.new
+         count = 0
+
+         #text << '{\pard{\*\shppict{\pict'
+         text << '{\*\shppict{\pict'
+         text << "\\picscalex#{@x_scaling}" if @x_scaling != nil
+         text << "\\picscaley#{@y_scaling}" if @y_scaling != nil
+         text << "\\piccropl#{@left_crop}" if @left_crop != nil
+         text << "\\piccropr#{@right_crop}" if @right_crop != nil
+         text << "\\piccropt#{@top_crop}" if @top_crop != nil
+         text << "\\piccropb#{@bottom_crop}" if @bottom_crop != nil
+         text << "\\picw#{@width}\\pich#{@height}\\bliptag#{@id}"
+         text << "\\#{@type.id2name}\n"
+         @source.each_byte {|byte| @read << byte} if @source.eof? == false
+         @read.each do |byte|
+            text << ("%02x" % byte)
+            count += 1
+            if count == 40
+               text << "\n"
+               count = 0
+            end
+         end
+         #text << "\n}}\\par}"
+         text << "\n}}"
+
+         text.string
+      end
+
+      # This method is used to determine the underlying endianness of a
+      # platform.
+      def get_endian
+         [0, 125].pack('c2').unpack('s') == [125] ? BIG_ENDIAN : LITTLE_ENDIAN
+      end
+
+      # This method converts an array to an integer. The array must be either
+      # two or four bytes in length.
+      #
+      # ==== Parameters
+      # array::    A reference to the array containing the data to be converted.
+      # signed::   A boolean to indicate whether the value is signed. Defaults
+      #            to false.
+      def to_integer(array, signed=false)
+         from = nil
+         to   = nil
+         data = []
+
+         if array.size == 2
+            data.concat(get_endian == BIG_ENDIAN ? array.reverse : array)
+            from = 'C2'
+            to   = signed ? 's' : 'S'
+         else
+            data.concat(get_endian == BIG_ENDIAN ? array[0,4].reverse : array)
+            from = 'C4'
+            to   = signed ? 'l' : 'L'
+         end
+         data.pack(from).unpack(to)[0]
+      end
+
+      # This method loads the data for an image from its source. The method
+      # accepts two call approaches. If called without a block then the method
+      # considers the size parameter it is passed. If called with a block the
+      # method executes until the block returns true.
+      #
+      # ==== Parameters
+      # size::  The maximum number of bytes to be read from the file. Defaults
+      #         to nil to indicate that the remainder of the file should be read
+      #         in.
+      def read_source(size=nil)
+         if block_given?
+            done = false
+
+            while done == false && @source.eof? == false
+              @read << @source.getbyte
+               done = yield @read[-1]
+            end
+         else
+            if size != nil
+               if size > 0
+                  total = 0
+                  while @source.eof? == false && total < size
+					  
+                     @read << @source.getbyte
+                     total += 1
+                  end
+               end
+            else
+               @source.each_byte {|byte| @read << byte}
+            end
+         end
+      end
+
+      # This method fetches details of the dimensions associated with an image.
+      def get_dimensions
+         dimensions = nil
+
+         # Check the image type.
+         if @type == JPEG
+            # Read until we can't anymore or we've found what we're looking for.
+            done = false
+            while @source.eof? == false && done == false
+               # Read to the next marker.
+               read_source {|c| c == 0xff} # Read to the marker.
+               read_source {|c| c != 0xff} # Skip any padding.
+
+               if @read[-1] >= 0xc0 && @read[-1] <= 0xc3
+                  # Read in the width and height details.
+                  read_source(7)
+                  dimensions = @read[-4,4].pack('C4').unpack('nn').reverse
+                  done       = true
+               else
+                  # Skip the marker block.
+                  read_source(2)
+                  read_source(@read[-2,2].pack('C2').unpack('n')[0] - 2)
+               end
+            end
+         elsif @type == PNG
+            # Read in the data to contain the width and height.
+            read_source(16)
+            dimensions = @read[-8,8].pack('C8').unpack('N2')
+         elsif @type == BITMAP
+            # Read in the data to contain the width and height.
+            read_source(18)
+            dimensions = [to_integer(@read[-8,4]), to_integer(@read[-4,4])]
+         end
+
+         dimensions
+      end
+
+      private :read_source, :get_file_type, :to_integer, :get_endian,
+              :get_dimensions
+   end # End of the ImageNode class.
+
+
    # This class represents an RTF document. In actuality it is just a
    # specialised Node type that cannot be assigned a parent and that holds
    # document font, colour and information tables.
@@ -1235,6 +1492,14 @@ module RTF
          @style         = style == nil ? DocumentStyle.new : style
          @headers       = [nil, nil, nil, nil]
          @footers       = [nil, nil, nil, nil]
+         @id            = 0
+      end
+
+      # This method provides a method that can be called to generate an
+      # identifier that is unique within the document.
+      def get_id
+         @id += 1
+         Time.now().strftime('%d%m%y') + @id.to_s
       end
 
       # Attribute accessor.