prawn 2.0.2 → 2.3.0

data/spec/grid_spec.rb

@@ -1,95 +0,0 @@
-# encoding: utf-8
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "A document's grid" do
-  before do
-    @pdf = Prawn::Document.new
-  end
-
-  it "should allow definition of a grid" do
-    @pdf.define_grid(:columns => 5, :rows => 8, :gutter => 0.1)
-    expect(@pdf.grid.columns).to eq(5)
-    expect(@pdf.grid.rows).to eq(8)
-    expect(@pdf.grid.gutter).to eq(0.1)
-  end
-
-  it "should allow re-definition of a grid" do
-    @pdf.define_grid(:columns => 5, :rows => 8, :gutter => 0.1)
-    expect(@pdf.grid.columns).to eq(5)
-    expect(@pdf.grid.rows).to eq(8)
-    expect(@pdf.grid.gutter).to eq(0.1)
-    @pdf.define_grid(:columns => 3, :rows => 6, :gutter => 0.1)
-    expect(@pdf.grid.columns).to eq(3)
-    expect(@pdf.grid.rows).to eq(6)
-    expect(@pdf.grid.gutter).to eq(0.1)
-  end
-
-  describe "when a grid is defined" do
-    before do
-      @num_columns = 5
-      @num_rows = 8
-      @gutter = 10.0
-      @pdf.define_grid(
-        :columns => @num_columns,
-        :rows => @num_rows,
-        :gutter => @gutter
-      )
-    end
-
-    it "should compute the column width" do
-      expect(@pdf.grid.column_width * @num_columns.to_f +
-        @gutter * (@num_columns - 1).to_f).to eq(@pdf.bounds.width)
-    end
-
-    it "should compute the row height" do
-      expect(@pdf.grid.row_height * @num_rows.to_f +
-        @gutter * (@num_rows - 1).to_f).to eq(@pdf.bounds.height)
-    end
-
-    it "should give the edges of a grid box" do
-      grid_width = (@pdf.bounds.width.to_f -
-        (@gutter * (@num_columns - 1).to_f)) / @num_columns.to_f
-      grid_height = (@pdf.bounds.height.to_f -
-        (@gutter * (@num_rows - 1).to_f)) / @num_rows.to_f
-
-      exp_tl_x = (grid_width + @gutter.to_f) * 4.0
-      exp_tl_y = @pdf.bounds.height.to_f - (grid_height + @gutter.to_f)
-
-      expect(@pdf.grid(1, 4).top_left).to eq([exp_tl_x, exp_tl_y])
-      expect(@pdf.grid(1, 4).top_right).to eq([exp_tl_x + grid_width, exp_tl_y])
-      expect(@pdf.grid(1, 4).bottom_left).to eq([exp_tl_x, exp_tl_y - grid_height])
-      expect(@pdf.grid(1, 4).bottom_right).to eq([exp_tl_x + grid_width, exp_tl_y - grid_height])
-    end
-
-    it "should give the edges of a multiple grid boxes" do
-      # Hand verified.  Cheating a bit.  Don't tell.
-      expect(@pdf.grid([1, 3], [2, 5]).top_left).to eq([330.0, 628.75])
-      expect(@pdf.grid([1, 3], [2, 5]).top_right).to eq([650.0, 628.75])
-      expect(@pdf.grid([1, 3], [2, 5]).bottom_left).to eq([330.0, 456.25])
-      expect(@pdf.grid([1, 3], [2, 5]).bottom_right).to eq([650.0, 456.25])
-    end
-
-    it "should draw outlines without changing global default colors to grid color" do
-      @pdf.grid.show_all('cccccc')
-
-      colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
-      expect(colors.fill_color).not_to eq([0.8, 0.8, 0.8])
-      expect(colors.stroke_color).not_to eq([0.8, 0.8, 0.8])
-
-      # Hardcoded default color as I haven't been able to come up with a stable converter
-      # between fill_color without lots code.
-      expect(colors.stroke_color).to eq([0.0, 0.0, 0.0])
-    end
-
-    it "should draw outlines without curent color settings" do
-      @pdf.fill_color "ccff00"
-      @pdf.stroke_color "ffcc00"
-
-      @pdf.grid.show_all
-
-      colors = PDF::Inspector::Graphics::Color.analyze(@pdf.render)
-      expect(colors.fill_color).to eq([0.8, 1.0, 0.0])
-      expect(colors.stroke_color).to eq([1.0, 0.8, 0.0])
-    end
-  end
-end

data/spec/image_handler_spec.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "ImageHandler" do
-  let(:image_handler) { Prawn::ImageHandler.new }
-
-  let(:handler_a) { mock("Handler A") }
-  let(:handler_b) { mock("Handler B") }
-
-  it "finds the image handler for an image" do
-    handler_a.expects(:can_render? => true)
-
-    image_handler.register(handler_a)
-    image_handler.register(handler_b)
-
-    handler = image_handler.find("arbitrary blob")
-    expect(handler).to eq(handler_a)
-  end
-
-  it "can prepend handlers" do
-    handler_b.expects(:can_render? => true)
-
-    image_handler.register(handler_a)
-    image_handler.register!(handler_b)
-
-    handler = image_handler.find("arbitrary blob")
-    expect(handler).to eq(handler_b)
-  end
-
-  it "can unregister a handler" do
-    handler_b.expects(:can_render? => true)
-
-    image_handler.register(handler_a)
-    image_handler.register(handler_b)
-
-    image_handler.unregister(handler_a)
-
-    handler = image_handler.find('arbitrary blob')
-    expect(handler).to eq(handler_b)
-  end
-
-  it "raises an error when no matching handler is found" do
-    handler_a.expects(:can_render? => false)
-    handler_b.expects(:can_render? => false)
-
-    image_handler.register(handler_a)
-    image_handler.register(handler_b)
-
-    expect { image_handler.find("arbitrary blob") }.
-      to(raise_error(Prawn::Errors::UnsupportedImageType))
-  end
-end

data/spec/images_spec.rb

@@ -1,167 +0,0 @@
-# encoding: utf-8
-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-require 'set'
-require 'pathname'
-
-describe "the image() function" do
-  before(:each) do
-    @filename = "#{Prawn::DATADIR}/images/pigs.jpg"
-    create_pdf
-  end
-
-  it "should only embed an image once, even if it's added multiple times" do
-    @pdf.image @filename, :at => [100, 100]
-    @pdf.image @filename, :at => [300, 300]
-
-    output = @pdf.render
-    images = PDF::Inspector::XObject.analyze(output)
-    # there should be 2 images in the page resources
-    expect(images.page_xobjects.first.size).to eq(2)
-    # but only 1 image xobject
-    expect(output.scan(/\/Type \/XObject/).size).to eq(1)
-  end
-
-  it "should return the image info object" do
-    info =  @pdf.image(@filename)
-
-    expect(info).to be_a_kind_of(Prawn::Images::JPG)
-
-    expect(info.height).to eq(453)
-  end
-
-  it "should accept IO objects" do
-    file = File.open(@filename, "rb")
-    info = @pdf.image(file)
-
-    expect(info.height).to eq(453)
-  end
-
-  it "rewinds IO objects to be able to embed them multiply" do
-    file = File.open(@filename, "rb")
-
-    @pdf.image(file)
-    info = @pdf.image(file)
-    expect(info.height).to eq(453)
-  end
-
-  it "should accept Pathname objects" do
-    info = @pdf.image(Pathname.new(@filename))
-    expect(info.height).to eq(453)
-  end
-
-  context "setting the length of the bytestream" do
-    it "should correctly work with images from Pathname objects" do
-      info = @pdf.image(Pathname.new(@filename))
-      expect(@pdf).to have_parseable_xobjects
-    end
-
-    it "should correctly work with images from IO objects" do
-      info = @pdf.image(File.open(@filename, 'rb'))
-      expect(@pdf).to have_parseable_xobjects
-    end
-
-    it "should correctly work with images from IO objects not set to mode rb" do
-      info = @pdf.image(File.open(@filename, 'r'))
-      expect(@pdf).to have_parseable_xobjects
-    end
-  end
-
-  it "should raise_error an UnsupportedImageType if passed a BMP" do
-    filename = "#{Prawn::DATADIR}/images/tru256.bmp"
-    expect { @pdf.image filename, :at => [100, 100] }.to raise_error(Prawn::Errors::UnsupportedImageType)
-  end
-
-  it "should raise_error an UnsupportedImageType if passed an interlaced PNG" do
-    filename = "#{Prawn::DATADIR}/images/dice_interlaced.png"
-    expect { @pdf.image filename, :at => [100, 100] }.to raise_error(Prawn::Errors::UnsupportedImageType)
-  end
-
-  it "should bump PDF version to 1.5 or greater on embedding 16-bit PNGs" do
-    @pdf.image "#{Prawn::DATADIR}/images/16bit.png"
-    expect(@pdf.state.version).to be >= 1.5
-  end
-
-  it "should embed 16-bit alpha channels for 16-bit PNGs" do
-    @pdf.image "#{Prawn::DATADIR}/images/16bit.png"
-
-    output = @pdf.render
-    expect(output).to match(/\/BitsPerComponent 16/)
-    expect(output).not_to match(/\/BitsPerComponent 8/)
-  end
-
-  it "should flow an image to a new page if it will not fit on a page" do
-    @pdf.image @filename, :fit => [600, 600]
-    @pdf.image @filename, :fit => [600, 600]
-    output = StringIO.new(@pdf.render, 'r+')
-    hash = PDF::Reader::ObjectHash.new(output)
-    pages = hash.values.find { |obj| obj.is_a?(Hash) && obj[:Type] == :Pages }[:Kids]
-    expect(pages.size).to eq(2)
-    expect(hash[pages[0]][:Resources][:XObject].keys).to eq([:I1])
-    expect(hash[pages[1]][:Resources][:XObject].keys).to eq([:I2])
-  end
-
-  it "should not flow an image to a new page if it will fit on one page" do
-    @pdf.image @filename, :fit => [400, 400]
-    @pdf.image @filename, :fit => [400, 400]
-    output = StringIO.new(@pdf.render, 'r+')
-    hash = PDF::Reader::ObjectHash.new(output)
-    pages = hash.values.find { |obj| obj.is_a?(Hash) && obj[:Type] == :Pages }[:Kids]
-    expect(pages.size).to eq(1)
-    expect(Set.new(hash[pages[0]][:Resources][:XObject].keys)).to eq(
-      Set.new([:I1, :I2])
-    )
-  end
-
-  it "should not start a new page just for a stretchy bounding box" do
-    @pdf.expects(:start_new_page).times(0)
-    @pdf.bounding_box([0, @pdf.cursor], :width => @pdf.bounds.width) do
-      @pdf.image @filename
-    end
-  end
-
-  describe ":fit option" do
-    it "should fit inside the defined constraints" do
-      info = @pdf.image @filename, :fit => [100, 400]
-      expect(info.scaled_width).to be <= 100
-      expect(info.scaled_height).to be <= 400
-
-      info = @pdf.image @filename, :fit => [400, 100]
-      expect(info.scaled_width).to be <= 400
-      expect(info.scaled_height).to be <= 100
-
-      info = @pdf.image @filename, :fit => [604, 453]
-      expect(info.scaled_width).to eq(604)
-      expect(info.scaled_height).to eq(453)
-    end
-    it "should move text position" do
-      @y = @pdf.y
-      info = @pdf.image @filename, :fit => [100, 400]
-      expect(@pdf.y).to be < @y
-    end
-  end
-
-  describe ":at option" do
-    it "should not move text position" do
-      @y = @pdf.y
-      info = @pdf.image @filename, :at => [100, 400]
-      expect(@pdf.y).to eq(@y)
-    end
-  end
-
-  describe ":width option without :height option" do
-    it "scales the width and height" do
-      info = @pdf.image @filename, :width => 225
-      expect(info.scaled_height).to eq(168.75)
-      expect(info.scaled_width).to eq(225.0)
-    end
-  end
-
-  describe ":height option without :width option" do
-    it "scales the width and height" do
-      info = @pdf.image @filename, :height => 225
-      expect(info.scaled_height).to eq(225.0)
-      expect(info.scaled_width).to eq(300.0)
-    end
-  end
-end

data/spec/inline_formatted_text_parser_spec.rb

@@ -1,568 +0,0 @@
-# -*- coding: utf-8 -*-
-require File.join(File.expand_path(File.dirname(__FILE__)), "spec_helper")
-
-describe "Text::Formatted::Parser#format" do
-  it "should handle sup" do
-    string = "<sup>superscript</sup>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "superscript",
-                           :styles => [:superscript],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should handle sub" do
-    string = "<sub>subscript</sub>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "subscript",
-                           :styles => [:subscript],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should handle rgb" do
-    string = "<color rgb='#ff0000'>red text</color>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "red text",
-                           :styles => [],
-                           :color => "ff0000",
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "# should be optional in rgb" do
-    string = "<color rgb='ff0000'>red text</color>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "red text",
-                           :styles => [],
-                           :color => "ff0000",
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should handle cmyk" do
-    string = "<color c='0' m='100' y='0' k='0'>magenta text</color>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "magenta text",
-                           :styles => [],
-                           :color => [0, 100, 0, 0],
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should handle fonts" do
-    string = "<font name='Courier'>Courier text</font>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "Courier text",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => "Courier",
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should handle size" do
-    string = "<font size='14'>14 point text</font>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "14 point text",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => 14,
-                           :character_spacing => nil)
-  end
-  it "should handle character_spacing" do
-    string = "<font character_spacing='2.5'>extra character spacing</font>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "extra character spacing",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => 2.5)
-  end
-  it "should handle links" do
-    string = "<link href='http://example.com'>external link</link>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "external link",
-                           :styles => [],
-                           :color => nil,
-                           :link => "http://example.com",
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should handle local links" do
-    string = "<link local='/home/example/foo.bar'>local link</link>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "local link",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => "/home/example/foo.bar",
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should handle anchors" do
-    string = "<link anchor='ToC'>internal link</link>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "internal link",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => "ToC",
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should handle higher order characters properly" do
-    string = "<b>©\n©</b>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[0]).to eq(:text => "©",
-                           :styles => [:bold],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[1]).to eq(:text => "\n",
-                           :styles => [:bold],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[2]).to eq(:text => "©",
-                           :styles => [:bold],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should convert &lt; &gt;, and &amp; to <, >, and &, respectively" do
-    string = "hello <b>&lt;, &gt;, and &amp;</b>"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[1]).to eq(:text => "<, >, and &",
-                           :styles => [:bold],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should handle double qoutes around tag attributes" do
-    string = 'some <font size="14">sized</font> text'
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[1]).to eq(:text => "sized",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => 14,
-                           :character_spacing => nil)
-  end
-  it "should handle single qoutes around tag attributes" do
-    string = "some <font size='14'>sized</font> text"
-    array = Prawn::Text::Formatted::Parser.format(string)
-    expect(array[1]).to eq(:text => "sized",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => 14,
-                           :character_spacing => nil)
-  end
-  it "should construct a formatted text array from a string" do
-    string = "hello <b>world\nhow <i>are</i></b> you?"
-    array = Prawn::Text::Formatted::Parser.format(string)
-
-    expect(array[0]).to eq(:text => "hello ",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[1]).to eq(:text => "world",
-                           :styles => [:bold],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[2]).to eq(:text => "\n",
-                           :styles => [:bold],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[3]).to eq(:text => "how ",
-                           :styles => [:bold],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[4]).to eq(:text => "are",
-                           :styles => [:bold, :italic],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[5]).to eq(:text => " you?",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should accept <strong> as an alternative to <b>" do
-    string = "<strong>bold</strong> not bold"
-    array = Prawn::Text::Formatted::Parser.format(string)
-
-    expect(array[0]).to eq(:text => "bold",
-                           :styles => [:bold],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[1]).to eq(:text => " not bold",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should accept <em> as an alternative to <i>" do
-    string = "<em>italic</em> not italic"
-    array = Prawn::Text::Formatted::Parser.format(string)
-
-    expect(array[0]).to eq(:text => "italic",
-                           :styles => [:italic],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[1]).to eq(:text => " not italic",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-  it "should accept <a> as an alternative to <link>" do
-    string = "<a href='http://example.com'>link</a> not a link"
-    array = Prawn::Text::Formatted::Parser.format(string)
-
-    expect(array[0]).to eq(:text => "link",
-                           :styles => [],
-                           :color => nil,
-                           :link => "http://example.com",
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-    expect(array[1]).to eq(:text => " not a link",
-                           :styles => [],
-                           :color => nil,
-                           :link => nil,
-                           :anchor => nil,
-                           :local => nil,
-                           :font => nil,
-                           :size => nil,
-                           :character_spacing => nil)
-  end
-
-  it "should turn <br>, <br/> into newline" do
-    array = Prawn::Text::Formatted::Parser.format("hello<br>big<br/>world")
-    expect(array.map { |frag| frag[:text] }.join).to eq("hello\nbig\nworld")
-  end
-end
-
-describe "Text::Formatted::Parser#to_string" do
-  it "should handle sup" do
-    string = "<sup>superscript</sup>"
-    array = [{ :text => "superscript",
-               :styles => [:superscript],
-               :color => nil,
-               :link => nil,
-               :anchor => nil,
-               :local => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil }]
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should handle sub" do
-    string = "<sub>subscript</sub>"
-    array = [{ :text => "subscript",
-               :styles => [:subscript],
-               :color => nil,
-               :link => nil,
-               :anchor => nil,
-               :local => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil }]
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should handle rgb" do
-    string = "<color rgb='ff0000'>red text</color>"
-    array = [{ :text => "red text",
-               :styles => [],
-               :color => "ff0000",
-               :link => nil,
-               :anchor => nil,
-               :local => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil }]
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should handle cmyk" do
-    string = "<color c='0' m='100' y='0' k='0'>magenta text</color>"
-    array = [{ :text => "magenta text",
-               :styles => [],
-               :color => [0, 100, 0, 0],
-               :link => nil,
-               :anchor => nil,
-               :local => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil }]
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should handle fonts" do
-    string = "<font name='Courier'>Courier text</font>"
-    array = [{ :text => "Courier text",
-               :styles => [],
-               :color => nil,
-               :link => nil,
-               :anchor => nil,
-               :local => nil,
-               :font => "Courier",
-               :size => nil,
-               :character_spacing => nil }]
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should handle size" do
-    string = "<font size='14'>14 point text</font>"
-    array = [{ :text => "14 point text",
-               :styles => [],
-               :color => nil,
-               :link => nil,
-               :anchor => nil,
-               :local => nil,
-               :font => nil,
-               :size => 14,
-               :character_spacing => nil }]
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should handle character spacing" do
-    string = "<font character_spacing='2.5'>2.5 extra character spacing</font>"
-    array = [{ :text => "2.5 extra character spacing",
-               :styles => [],
-               :color => nil,
-               :link => nil,
-               :anchor => nil,
-               :local => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => 2.5 }]
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should handle links" do
-    array = [{ :text => "external link",
-               :styles => [],
-               :color => nil,
-               :link => "http://example.com",
-               :anchor => nil,
-               :local => nil,
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil }]
-    string = "<link href='http://example.com'>external link</link>"
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should handle anchors" do
-    array = [{ :text => "internal link",
-               :styles => [],
-               :color => nil,
-               :link => nil,
-               :anchor => "ToC",
-               :font => nil,
-               :size => nil,
-               :character_spacing => nil }]
-    string = "<link anchor='ToC'>internal link</link>"
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should convert <, >, and & to &lt; &gt;, and &amp;, respectively" do
-    array = [
-      {
-        :text => "hello ",
-        :styles => [],
-        :color => nil,
-        :link => nil,
-        :font => nil,
-        :size => nil,
-        :character_spacing => nil
-      },
-      {
-        :text => "<, >, and &",
-        :styles => [:bold],
-        :color => nil,
-        :link => nil,
-        :font => nil,
-        :size => nil,
-        :character_spacing => nil
-      }
-    ]
-    string = "hello <b>&lt;, &gt;, and &amp;</b>"
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-  it "should construct an HTML-esque string from a formatted text array" do
-    array = [
-      { :text => "hello ",
-        :styles => [],
-        :color => nil,
-        :link => nil,
-        :font => nil,
-        :size => 14,
-        :character_spacing => nil },
-      { :text => "world",
-        :styles => [:bold],
-        :color => nil,
-        :link => nil,
-        :font => nil,
-        :size => nil,
-        :character_spacing => nil },
-      { :text => "\n",
-        :styles => [:bold],
-        :color => nil,
-        :link => nil,
-        :font => nil,
-        :size => nil,
-        :character_spacing => nil },
-      { :text => "how ",
-        :styles => [:bold],
-        :color => nil,
-        :link => nil,
-        :font => nil,
-        :size => nil,
-        :character_spacing => nil },
-      { :text => "are",
-        :styles => [:bold, :italic],
-        :color => nil,
-        :link => nil,
-        :font => nil,
-        :size => nil,
-        :character_spacing => nil },
-      { :text => " you?",
-        :styles => [],
-        :color => nil,
-        :link => nil,
-        :font => nil,
-        :size => nil,
-        :character_spacing => nil }
-    ]
-    string = "<font size='14'>hello </font><b>world</b><b>\n</b><b>how </b><b><i>are</i></b> you?"
-    expect(Prawn::Text::Formatted::Parser.to_string(array)).to eq(string)
-  end
-end
-
-describe "Text::Formatted::Parser#array_paragraphs" do
-  it "should group fragments separated by newlines" do
-    array = [{ :text => "\nhello\nworld" },
-             { :text => "\n\n" },
-             { :text => "how" },
-             { :text => "are" },
-             { :text => "you" }]
-    target = [[{ :text => "\n" }],
-              [{ :text => "hello" }],
-              [{ :text => "world" }],
-              [{ :text => "\n" }],
-              [{ :text => "how" },
-               { :text => "are" },
-               { :text => "you" }]]
-    expect(Prawn::Text::Formatted::Parser.array_paragraphs(array)).to eq(target)
-  end
-
-  it "should work properly if ending in an empty paragraph" do
-    array = [{ :text => "\nhello\nworld\n" }]
-    target = [[{ :text => "\n" }],
-              [{ :text => "hello" }],
-              [{ :text => "world" }]]
-    expect(Prawn::Text::Formatted::Parser.array_paragraphs(array)).to eq(target)
-  end
-end