tn_pdf 0.0.2

data/.gitignore

@@ -0,0 +1,9 @@
+*.swp
+~*
+bin/
+.bundle
+.rspec
+coverage
+*.gem
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in tn_pdf.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    Ascii85 (1.0.1)
+    ZenTest (4.5.0)
+    activesupport (2.3.5)
+    autotest (4.4.6)
+      ZenTest (>= 4.4.1)
+    coderay (0.9.8)
+    diff-lcs (1.1.2)
+    method_source (0.4.1)
+      ruby_parser (>= 2.0.5)
+    pdf-reader (0.9.2)
+      Ascii85 (>= 0.9)
+    prawn (0.11.1)
+      pdf-reader (>= 0.9.0)
+      ttfunk (~> 1.0.0)
+    pry (0.8.3)
+      coderay (>= 0.9.7)
+      method_source (>= 0.4.0)
+      ruby_parser (>= 2.0.5)
+      slop (>= 1.5.3)
+    rcov (0.9.9)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.1)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    ruby_parser (2.0.6)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.5)
+    slop (1.6.0)
+    ttfunk (1.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  autotest
+  prawn (~> 0.11.1)
+  pry
+  rcov
+  rspec (~> 2.6.0)

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'spec/rake/spectask'
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('examples_with_rcov') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec,.bundle']
+end

data/lib/tn_pdf/box.rb

@@ -0,0 +1,72 @@
+module TnPDF
+  class PageSection
+
+    class Box
+      attr_reader :image_path, :image_options
+      attr_reader :text, :text_options
+
+      def initialize(options)
+        parse_options(options)
+      end
+
+      def render(document, pos, width, height=nil)
+        options_hash = { :width => width }
+        options_hash[:height] = height unless height.nil?
+
+        document.bounding_box(pos, options_hash) do
+          if has_image?
+            image_args = [image_path]
+            image_args << image_options unless image_options.empty?
+            document.image *image_args
+          end
+
+          if has_text?
+            text_args = [text]
+            text_args << text_options unless text_options.empty?
+            document.text *text_args
+          end
+        end
+      end
+
+      def has_image?
+        !image_path.nil?
+      end
+
+      def has_text?
+        !text.nil?
+      end
+
+      private
+
+      def parse_options(options)
+        options.to_options!
+
+        options[:align]  ||= :justify
+        options[:valign] ||= :center
+
+        if options[:text]
+          unless options[:text].kind_of? Hash
+            options[:text] = { :text => options[:text] }
+          end
+          options[:text][:align]  = options[:align]
+          options[:text][:valign] = options[:valign]
+
+          @text = options[:text][:text]
+          @text_options = options[:text].reject { |k,_| k == :text }
+        end
+
+        if options[:image]
+          unless options[:image].kind_of? Hash
+            options[:image] = { :path => options[:image] }
+          end
+          options[:image][:position] = options[:align]
+          options[:image][:vposition] = options[:valign]
+
+          @image_path = options[:image][:path]
+          @image_options = options[:image].reject { |k,_| k == :path }
+        end
+      end
+
+    end
+  end
+end

data/lib/tn_pdf/configuration.rb

@@ -0,0 +1,124 @@
+require 'yaml'
+module TnPDF
+
+  class Configuration
+    class << self
+
+
+      def [](property)
+        property = property.to_s
+        case property
+          when /^page_header_/
+            property_key = property.sub('page_header_','').to_sym
+            header[property_key]
+          when /^page_footer_/
+            property_key = property.sub('page_footer_','').to_sym
+            footer[property_key]
+          when /^table_/
+            property_key = property.sub('table_','').to_sym
+            table[property_key]
+          when /^column_/
+            property_key = property.sub('column_','').to_sym
+            column[property_key]
+          else
+            report[property.to_sym]
+        end
+      end
+
+      def report_properties_names
+        report.keys
+      end
+
+      def header_properties_names
+        header.keys
+      end
+
+      def footer_properties_names
+        footer.keys
+      end
+
+      def table_properties_names
+        table.keys
+      end
+
+      def properties_names
+        report_properties_names.map { |p| "report_#{p}" }  +
+          header_properties_names.map { |p| "page_header_#{p}" } +
+          footer_properties_names.map { |p| "page_footer_#{p}" } +
+          table_properties_names.map { |p| "table_#{p}" }
+      end
+
+      def load_from(yaml_file)
+        configurations = YAML.load_file(yaml_file)
+        configurations.to_options!
+        configurations.each_key do |item|
+          self.send(item).merge! configurations[item].to_options!
+        end
+      end
+
+      private
+
+      def report
+        @report ||= {
+          :page_size => "A4",
+          :page_layout => :landscape,
+          :left_margin => 1.cm,
+          :right_margin => 1.cm,
+          :top_margin => 0.cm,
+          :bottom_margin => 0.cm,
+          :font => "Courier",
+          :font_size => 10,
+        }
+      end
+
+      def header
+        @header ||= {
+          :height =>  1.cm,
+          :top => 0.5.cm,
+          :bottom => 0.2.cm,
+        }
+      end
+
+
+      def footer
+        @footer ||= {
+          :height =>  1.cm,
+          :top => 0.2.cm,
+          :bottom => 0.1.cm,
+        }
+      end
+
+      def table
+        @table ||= {
+          :align => :center,
+          :multipage_headers => true,
+          :borders => false,
+          :header_color => "FF0000",
+          :odd_row_color => "00FF00",
+          :even_row_color => "0000FF",
+        }
+      end
+
+      def column
+        @column ||= {
+          :currency => { :format => "%0.2f",
+                         :align => :right,
+                         :decimal => "," },
+
+          :number   => { :format => "%d",
+                         :align => :right},
+
+          :date => { :format => "%d/%m/%Y",
+                     :align  => :center },
+
+          :float => { :format => "%0.3f",
+                           :align => :right,
+                           :decimal => "," },
+
+          :text => { :format => "%s",
+                     :align => :left }
+        }
+      end
+    end
+  end
+end

data/lib/tn_pdf/page_section.rb

@@ -0,0 +1,56 @@
+module TnPDF
+  class PageSection
+    attr_reader :left, :right, :center
+    attr_reader :left_box, :center_box, :right_box
+    attr_writer :top, :bottom
+    attr_accessor :width, :height
+
+    def left=(options)
+      @left = options
+      options[:align] = :left
+      @left_box = Box.new(options)
+    end
+
+    def center=(options)
+      @center = options
+      options[:align] = :center
+      @center_box = Box.new(options)
+    end
+
+    def right=(options)
+      @right = options
+      options[:align] = :right
+      @right_box = Box.new(options)
+    end
+
+    def total_height
+      height + top + bottom
+    end
+
+    def boxes
+      [left_box, center_box, right_box].compact
+    end
+
+    def top
+      @top ||= 0
+    end
+
+    def bottom
+      @bottom ||= 0
+    end
+
+    def render(document, position)
+      width ||= document.bounds.width
+
+      box_width = width/(boxes.count)
+
+      boxes.inject(0) do |offset, box|
+        x_pos = position[0] + offset
+        y_pos = position[1] - top
+        box.render(document, [x_pos, y_pos], box_width, height )
+        offset += box_width
+      end
+    end
+
+  end
+end

data/lib/tn_pdf/report.rb

@@ -0,0 +1,131 @@
+module TnPDF
+  class Report
+    attr_reader :page_header, :page_footer, :table, :record_collection
+    attr_accessor *Configuration.report_properties_names
+
+    def initialize(properties = {})
+      @page_header = PageSection.new
+      @page_footer = PageSection.new
+      @record_collection = Array.new
+      initialize_properties(properties)
+    end
+
+    class << self
+      private
+
+      def forward_property(object_name, property)
+        class_eval <<-STRING
+          def #{object_name}_#{property}
+          #{object_name}.#{property}
+          end
+
+          def #{object_name}_#{property}=(value)
+          #{object_name}.#{property} = value
+          end
+        STRING
+      end
+
+    end
+
+    Configuration.header_properties_names.each do |property|
+      forward_property("page_header", property)
+    end
+
+    Configuration.footer_properties_names.each do |property|
+      forward_property("page_footer", property)
+    end
+
+    Configuration.table_properties_names.each do |property|
+      forward_property("table", property)
+    end
+
+    def record_collection=(collection)
+      unless collection.kind_of? Array
+        raise ArgumentError, "collection should be an Array!"
+      end
+      @record_collection = table.collection = collection
+    end
+
+    def table_columns
+      table.columns || Array.new
+    end
+
+    def table_columns=(columns)
+      raise ArgumentError unless columns.kind_of? Array
+      columns.each do |column|
+        table.add_column column
+      end
+    end
+
+    def render(filename)
+      document_width = document.bounds.width
+      page_header_position = [0, document.cursor]
+      page_footer_position = [0, Configuration[:page_footer_height]]
+
+      document.font(font)
+      document.font_size(font_size)
+
+      document.repeat :all do
+        page_header.render(document, page_header_position)
+        document.stroke_horizontal_rule
+      end
+
+      table_height = page_body_height
+      document.bounding_box([0, page_body_height+page_footer.total_height],
+                            :width  => document.bounds.width) do
+        table.render(document, table_height)
+      end
+
+      document.repeat :all do
+        page_footer.render(document, page_footer_position)
+      end
+
+      document.render_file filename
+    end
+
+    def page_body_height
+      height  = document.bounds.height
+      height -= page_header.total_height
+      height -= page_footer.total_height
+    end
+
+    def document
+      @document ||= Prawn::Document.new(properties)
+    end
+
+    def table
+      @table ||= Table.new
+    end
+
+    # Configurable properties
+
+    def properties
+      Configuration.report_properties_names.inject({}) do |properties_hash, property|
+        properties_hash[property] = send(property)
+        properties_hash
+      end
+    end
+
+    private
+
+    def initialize_properties(properties)
+      owned_properties  = Configuration.report_properties_names
+      owned_properties += Configuration.footer_properties_names.map do |p|
+        "page_footer_#{p}"
+      end
+      owned_properties += Configuration.header_properties_names.map do |p|
+        "page_header_#{p}"
+      end
+      owned_properties += Configuration.table_properties_names.map do |p|
+        "table_#{p}"
+      end
+
+      owned_properties.each do |property|
+        properties[property] ||= Configuration[property]
+        send(:"#{property}=", properties[property])
+      end
+
+    end
+
+  end
+end

data/lib/tn_pdf/table.rb

@@ -0,0 +1,91 @@
+require 'tn_pdf/table_column'
+require 'prawn'
+
+module TnPDF
+  class Table
+    attr_accessor *Configuration.table_properties_names
+
+    def initialize
+      Configuration.table_properties_names.each do |property|
+        send("#{property}=", Configuration["table_#{property}"])
+      end
+    end
+
+    def columns_hash
+      columns_hash = ActiveSupport::OrderedHash.new
+      columns.inject(columns_hash) do |hash, column|
+        hash[column.header] = column.to_proc
+        hash
+      end
+    end
+
+    def columns_headers
+      columns.map(&:header)
+    end
+
+    def collection
+      @collection ||= Array.new
+    end
+
+    def collection=(collection)
+      raise ArgumentError unless collection.kind_of? Array
+      @collection = collection
+    end
+
+    def add_column(column)
+      unless column.kind_of? Column
+        column = Column.new(column)
+      end
+      columns << column
+    end
+
+    def rows
+      collection.map do |object|
+        columns.map do |column|
+          column.value_for(object)
+        end
+      end
+    end
+
+    def render(document, max_height)
+      table = document.make_table([columns_headers]+rows) do |table|
+        table.header = self.multipage_headers
+        table.cells.borders = [] unless self.borders
+        table.row_colors = [self.odd_row_color, self.even_row_color]
+        table.row(0).background_color = self.header_color
+
+        columns.each_with_index do |column, index|
+          style = column.style.reject { |k, v| [:format, :decimal].include? k }
+          table.columns(index).style(style)
+        end
+      end
+      x_pos = x_pos_on(document, table.width)
+      document.bounding_box([x_pos, document.cursor],
+                            :width => table.width,
+                            :height => max_height) do
+        table.draw
+      end
+    end
+
+    def columns
+      @columns ||= []
+    end
+
+    private
+
+    def x_pos_on(document, table_width)
+      case align
+        when :left
+          0
+        when :center
+          (document.bounds.right - table_width)/2.0
+        when :right
+          document.bounds.right - table_width
+        else
+          0
+      end
+    end
+
+  end
+
+end

data/lib/tn_pdf/table_column.rb

@@ -0,0 +1,67 @@
+module TnPDF
+  class Table
+
+    class Column
+      attr_reader :header, :proc, :collection, :style
+
+      alias_method :to_proc, :proc
+      def initialize(arguments)
+        raise ArgumentError unless valid_column_args?(arguments)
+        @header = arguments[0].to_s
+        @proc   = arguments[1].to_proc
+        @style = style_for(arguments[2])
+      end
+
+      def values_for(collection)
+        collection.map do |object|
+          value_for(object)
+        end
+      end
+
+      def value_for(object)
+        value = @proc.call(object)
+        method = if value.respond_to?(:strftime)
+                   value.method(:strftime)
+                 elsif value.respond_to?(:sprintf)
+                   value.method(:sprintf)
+                 else
+                   method(:sprintf)
+                 end
+        string = method.arity == 1 ?
+                   method.call(style[:format]) :
+                   method.call(style[:format], value)
+
+        string.gsub!(".", style[:decimal]) if style[:decimal]
+        return string
+      rescue TypeError
+        puts "WARNING: Bad format '#{style[:format]}' for value '#{value}'"
+        return value.to_s
+      end
+
+      private
+
+      def valid_column_args?(column_args)
+        validity  = true
+        validity &= column_args.kind_of? Array
+        validity &= column_args.count == 2 || column_args.count == 3
+        validity &= column_args[0].respond_to?(:to_s)
+        validity &= column_args[1].respond_to?(:to_proc)
+      rescue NoMethodError
+        valid = false
+      ensure
+        return validity
+      end
+
+      def style_for(type)
+        if type.nil?
+          {:format => "%s"}
+        elsif type.kind_of? Symbol
+          Configuration["column_#{type}"]
+        else
+          type
+        end
+      end
+    end
+
+  end
+end

data/lib/tn_pdf/version.rb

@@ -0,0 +1,3 @@
+module TnPDF
+  VERSION = "0.0.2"
+end

data/lib/tn_pdf.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'active_support' # Because of to_options!
+require 'prawn'
+require 'prawn/measurement_extensions'
+
+require 'tn_pdf/configuration'
+require 'tn_pdf/report'
+require 'tn_pdf/page_section'
+require 'tn_pdf/box'
+require 'tn_pdf/table'
+require 'tn_pdf/table_column'

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# Adds the "lib" dir to the load path
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'tn_pdf'
+
+# Used to 'stub' needed classes that doesn't exist (yet)
+class EmptyClass
+  def method_missing(method,*args)
+    nil
+  end
+end
+
+require 'prawn'
+
+# Utility methods:
+
+def random_string
+  (Time.now.to_f+rand(1000)).to_s
+end

data/spec/tn_pdf/box_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+module TnPDF
+  class PageSection
+
+    describe Box do
+
+      subject { Box.new( {} ) }
+
+      describe "creation options" do
+        it "accept texts and/or images" do
+          assigning_nice_values = lambda do
+            Box.new( { :text  => "text" } )
+            Box.new( { :image => "image.jpg" } )
+            Box.new( { :text  => "text", :image => "image.jpg" } )
+          end
+          assigning_nice_values.should_not raise_error
+        end
+
+        it "accepts extra text options to prawn by passing hashes" do
+          document = Prawn::Document.new
+          box = Box.new( :text => {:text => "text", :font => "DejaVu Sans"} )
+
+          document.should_receive(:text).with("text", hash_including(:font => "DejaVu Sans") )
+          box.render(document, [0,0], 100)
+        end
+
+        it "accepts extra image options to prawn by passing hashes" do
+          document = Prawn::Document.new
+          box = Box.new( :image => {:path => "image.jpg", :width => 1.cm } )
+
+          document.should_receive(:image).with("image.jpg", hash_including(:width => 1.cm) )
+          box.render(document, [0,0], 100)
+        end
+      end
+
+      describe "#render" do
+        let(:document) { Prawn::Document.new }
+
+        it "creates a bounding box on the provided document" do
+          document.should_receive(:bounding_box).with([0,0], hash_including(:width => 20.cm) )
+          subject.render(document, [0,0], 20.cm)
+        end
+
+        specify "when the box contains text, the text is rendered" do
+          subject = Box.new({ :text => "some text" })
+
+          document.should_receive(:text).with("some text", anything())
+          subject.render(document, [0, 0], 20.cm)
+        end
+      end
+    end
+  end
+end

data/spec/tn_pdf/page_section_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+module TnPDF
+
+  describe PageSection do
+
+    describe "its left, center and right parts" do
+      let(:parts) { [:left, :center, :right] }
+
+      specify "exist and can be set" do
+        parts.each do |part|
+          subject.should respond_to(part)
+          subject.should respond_to(:"#{part}=")
+        end
+      end
+
+      specify "are accessible as hashes, and also as boxes" do
+        parts.each do |part|
+          subject.send("#{part}=", {} )
+          subject.send("#{part}").should be_kind_of Hash
+          subject.send("#{part}_box").should be_kind_of PageSection::Box
+        end
+      end
+    end
+
+    describe "#render" do
+      let(:document) { Prawn::Document.new }
+
+      it "renders each of the defined boxes on the provided document" do
+        subject.left   = {:text => "Blah"}
+        subject.center = {:text => "Blah"}
+        subject.right  = {:text => "Blah"}
+
+        subject.left_box.should_receive(:render)
+        subject.center_box.should_receive(:render)
+        subject.right_box.should_receive(:render)
+
+        subject.render(document, [0, 0])
+      end
+
+      it "divides the available width between the defined boxes" do
+        subject.left   = {:text => "Blah"}
+        subject.right  = {:text => "Blah"}
+
+        subject.left_box.should_receive(:render).with(
+          document, [0, 0], document.bounds.width/2, nil)
+
+        subject.render(document, [0, 0])
+
+
+        subject = PageSection.new
+        subject.left = {:text => "Blah"}
+
+        subject.left_box.should_receive(:render).with(
+          document, [0, 0], document.bounds.width, nil)
+
+        subject.render(document, [0, 0])
+      end
+
+      it "translates the second and third boxes to the right" do
+        subject.left   = {:text => "Blah"}
+        subject.center = {:text => "Blah"}
+        subject.right  = {:text => "Blah"}
+
+        box_width = document.bounds.width/3
+        subject.left_box.should_receive(:render).with(
+          document, [0, 0], box_width, nil)
+
+        subject.center_box.should_receive(:render).with(
+          document, [box_width, 0], box_width, nil)
+
+        subject.right_box.should_receive(:render).with(
+          document, [box_width*2, 0], box_width, nil)
+
+        subject.render(document, [0, 0])
+      end
+    end
+  end
+end

data/spec/tn_pdf/report_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+module TnPDF
+  const_set("PageSection", EmptyClass) unless const_defined?("PageSection")
+  const_set("Table", EmptyClass) unless const_defined?("Table")
+
+  describe Report do
+
+    describe "#page_header and #page_footer" do
+      specify "are page sections" do
+        subject.page_header.should be_kind_of TnPDF::PageSection
+        subject.page_footer.should be_kind_of TnPDF::PageSection
+      end
+
+      specify "aren't publicly modifiable" do
+        direct_assignment = lambda do
+          subject.page_header = :some_section
+          subject.page_footer = :some_section
+        end
+        direct_assignment.should raise_error
+      end
+
+      specify "are modifiable by page_header_left and page_footer_left" do
+        subject.page_header.should_receive(:left=)
+        subject.page_footer.should_receive(:left=)
+
+        subject.page_header_left = { :text => random_string }
+        subject.page_footer_left = { :text => random_string }
+      end
+
+      specify "are modifiable by page_header_right and page_footer_right" do
+        subject.page_header.should_receive(:right=)
+        subject.page_footer.should_receive(:right=)
+
+        subject.page_header_right = { :text => random_string }
+        subject.page_footer_right = { :text => random_string }
+      end
+
+      specify "are modifiable by page_header_center and page_footer_center" do
+        subject.page_header.should_receive(:center=)
+        subject.page_footer.should_receive(:center=)
+
+        subject.page_header_center = { :text => random_string }
+        subject.page_footer_center = { :text => random_string }
+      end
+
+    end
+
+    describe "#record_collection" do
+      it "is a kind of array" do
+        subject.record_collection.should be_kind_of Array
+      end
+
+      it "is settable by the record_collection= method" do
+        subject.record_collection = [:a, :b, :c]
+        subject.record_collection.should == [:a, :b, :c]
+      end
+
+      it "doesn't accept non-array arguments" do
+        invalid_values = [ Hash.new, :collection, "collection", 123]
+        invalid_values.each do |invalid_value|
+          setting_invalid_value = lambda do
+            subject.record_collection = invalid_value
+          end
+          setting_invalid_value.should raise_error
+        end
+      end
+    end
+
+    describe "#table_columns" do
+      it "is a kind of array" do
+        subject.table_columns.should be_kind_of Array
+      end
+    end
+
+    describe "#table_columns=" do
+      it "is a proxy to Table#add_column" do
+        subject.table.should_receive(:add_column)
+
+        column = [ [ 'String' , :to_s ] ]
+        subject.table_columns = column
+      end
+
+      it "works with multiple columns" do
+        subject.table.should_receive(:add_column).exactly(3).times
+
+        columns = [ [ 'String' => :to_s] ,
+                    [ 'Object id' => :object_id] ,
+                    [ 'Name'   => :name] ]
+        subject.table_columns = columns
+      end
+    end
+
+    describe "#document" do
+      it "returns the Prawn::Document associated with the report" do
+        subject.document.should be_kind_of Prawn::Document
+      end
+    end
+
+    it "has all the properties defined on Report" do
+      Configuration.properties_names do |property|
+        subject.should respond_to(property)
+        subject.should respond_to(:"#{property}=")
+      end
+    end
+
+    specify "passing a hash of options on initialization works" do
+      properties = { :page_layout => :portrait,
+                     :left_margin => 5.cm }
+      subject = Report.new(properties)
+      subject.page_layout.should == :portrait
+      subject.left_margin.should == 5.cm
+    end
+  end
+end

data/spec/tn_pdf/table_column_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+module TnPDF
+  class Table
+    describe Column do
+
+      context "to be valid, needs a parameter that is" do
+
+        specify "an Array" do
+          creating_bad_column = Proc.new { Table::Column.new :not_an_array }
+          creating_bad_column.should raise_error ArgumentError
+        end
+
+        specify "an Array whose 1st member can be coerced into a String" do
+          bad_string = /not_a_string/
+            class << bad_string
+              undef_method(:to_s)
+            end
+          creating_bad_column = Proc.new { Table::Column.new [bad_string, :to_s] }
+          creating_bad_column.should raise_error ArgumentError
+        end
+
+        specify "an Array whose 2nd member can be coerced into a Proc" do
+          bad_columns = [["String", "to_s"], ["String", 3], ["String", /to_s/]]
+          bad_columns.each do |bad_column|
+            creating_bad_column = Proc.new { Table::Column.new bad_column }
+            creating_bad_column.should raise_error ArgumentError
+          end
+        end
+      end
+
+      describe "#header" do
+        it "returns the string value that was passed as parameter" do
+          column_args = ["String", :to_s]
+          column = Table::Column.new(column_args)
+          column.header.should == "String"
+        end
+      end
+
+      describe "#to_proc" do
+        it "returns the proc that was passed as parameter" do
+          my_proc = Proc.new { |object| object.to_s }
+          column  = Table::Column.new([123, my_proc])
+          column.to_proc.should == my_proc
+        end
+      end
+
+      describe "#values_for" do
+        it "maps received values to the underlying proc" do
+          column = Table::Column.new(["String", :to_s])
+          numbers = (1..3).to_a
+          column.values_for(numbers).should == %w[1 2 3]
+        end
+      end
+
+      describe "#value_for" do
+        it "maps received object to the underlying proc" do
+          column = Table::Column.new(["String", :to_s])
+          column.value_for(25).should == "25"
+        end
+      end
+    end
+  end
+end

data/spec/tn_pdf/table_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+module TnPDF
+  class Table
+    const_set("Column",EmptyClass) unless const_defined?("Column")
+  end
+
+  describe Table do
+    describe "#columns_hash" do
+      it "is a kind of Hash" do
+        subject.columns_hash.should be_kind_of(Hash)
+      end
+
+      it "is ordered" do
+        subject.add_column ["A", :A]
+        subject.add_column ["B", :B]
+        subject.add_column ["C", :C]
+
+        subject.columns_hash.keys.should == %w[A B C]
+      end
+    end
+
+    describe "#collection" do
+      it "is a kind of Array" do
+        subject.collection.should be_kind_of(Array)
+      end
+
+      it "is settable, as long as the parameter is also an Array" do
+        setting_good_parameter = Proc.new do
+          subject.collection = [:a, :b, :c]
+        end
+        setting_good_parameter.should_not raise_error
+        subject.collection.should == [:a, :b, :c]
+      end
+
+      it "raises an error if someone tries to set it as a non-array" do
+        setting_bad_parameter = Proc.new do
+          subject.collection = :not_an_array
+        end
+        setting_bad_parameter.should raise_error
+        subject.collection.should_not == :not_an_array
+      end
+    end
+
+    describe "#add_column" do
+      let(:valid_column) { column = ["String", :to_s] }
+
+      it "adds a supplied column to the columns hash" do
+        adding_valid_column = Proc.new do
+          subject.add_column(valid_column)
+        end
+        adding_valid_column.should change(subject.columns, :count).by(1)
+      end
+
+      it "should the argument be a column, it adds directly" do
+        column = Table::Column.new [ "String", :to_s ]
+        subject.add_column(column)
+        subject.columns.should include(column)
+      end
+    end
+
+    describe "#columns_headers" do
+      it "returns the columns headers" do
+        subject.add_column ["String", :to_s]
+        subject.add_column ["Integer", :to_i]
+        subject.add_column ["Mean", :mean]
+
+        subject.columns_headers.should == %w[String Integer Mean]
+      end
+    end
+
+    describe "#rows" do
+      it "returns the values of the objects for each column" do
+        subject = Table.new # Just to be explicit
+        subject.add_column( ["String", :to_s] )
+        subject.add_column( ["Integer", :to_i] )
+        subject.add_column( ["Doubled", Proc.new { |x| x*2 } ] )
+
+        subject.collection = [1, 2, 3]
+        subject.rows.should == [ ["1", 1, 2],
+                                 ["2", 2, 4],
+                                 ["3", 3, 6] ]
+      end
+    end
+
+    describe "#render" do
+      let(:document) do
+         mock("Prawn::Document").as_null_object
+      end
+
+      let(:table) do
+        mock("Prawn::Table").as_null_object
+      end
+
+      it "instantiates a Prawn::Table instance" do
+        document.should_receive(:make_table).and_return(table)
+        subject.render(document, 0)
+      end
+    end
+  end
+end

data/tn_pdf.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tn_pdf/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tn_pdf"
+  s.version     = TnPDF::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Renato Riccieri Santos Zannon"]
+  s.email       = ["zannon@tecnologiaenegocios.com.br"]
+  s.summary = %q{A simple wrapper around prawn, devised to the generation of table-centric reports}
+
+  s.rubyforge_project = "tn_pdf"
+
+  s.add_dependency('prawn', '~> 0.11.1')
+  s.add_dependency('activesupport')
+
+  s.add_development_dependency('rspec', '~> 2.6.0')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: tn_pdf
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Renato Riccieri Santos Zannon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-31 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: prawn
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 11
+        - 1
+        version: 0.11.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id003
+description: 
+email: 
+- zannon@tecnologiaenegocios.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- lib/tn_pdf.rb
+- lib/tn_pdf/box.rb
+- lib/tn_pdf/configuration.rb
+- lib/tn_pdf/page_section.rb
+- lib/tn_pdf/report.rb
+- lib/tn_pdf/table.rb
+- lib/tn_pdf/table_column.rb
+- lib/tn_pdf/version.rb
+- spec/spec_helper.rb
+- spec/tn_pdf/box_spec.rb
+- spec/tn_pdf/page_section_spec.rb
+- spec/tn_pdf/report_spec.rb
+- spec/tn_pdf/table_column_spec.rb
+- spec/tn_pdf/table_spec.rb
+- tn_pdf.gemspec
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: tn_pdf
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A simple wrapper around prawn, devised to the generation of table-centric reports
+test_files: []
+