ruport 1.6.3 → 1.8.0

data/lib/ruport/formatter/csv.rb

@@ -14,16 +14,15 @@
 module Ruport
 
   # This formatter implements the CSV format for Ruport's Row, Table, Group
-  # and Grouping controllers.  It is a light wrapper around
-  # James Edward Gray II's FasterCSV.
+  # and Grouping controllers.
   #
   # === Rendering Options
   #                                                     
   # <tt>:style</tt> Used for grouping (:inline,:justified,:raw)      
   #
-  # <tt>:format_options</tt> A hash of FasterCSV options  
+  # <tt>:format_options</tt> A hash of CSV options
   #
-  # <tt>:formatter</tt> An existing FasterCSV object to write to
+  # <tt>:formatter</tt> An existing CSV object to write to
   #
   # <tt>:show_table_headers</tt> True by default
   #
@@ -35,7 +34,7 @@ module Ruport
                             Controller::Group, Controller::Grouping ]
     
     def initialize
-      require "fastercsv" unless RUBY_VERSION > "1.9"   
+      require "csv"
     end
 
     attr_writer :csv_writer
@@ -49,14 +48,14 @@ module Ruport
       options.format_options ||= template.format_options
     end
 
-    # Returns the current FCSV object or creates a new one if it has not
+    # Returns the current CSV object or creates a new one if it has not
     # been set yet. Note that FCSV(sig) has a cache and returns the *same*
     # FCSV object if writing to the same underlying output with the same
     # options.
     #
     def csv_writer
       @csv_writer ||= options.formatter ||
-        FCSV(output, options.format_options || {})
+        ::CSV.instance(output, **(options.format_options || {}))
     end
 
     # Generates table header by turning column_names into a CSV row.

data/lib/ruport/formatter/html.rb

@@ -40,12 +40,7 @@ module Ruport
     # This method does not do anything if options.show_table_headers is false
     # or the Data::Table has no column names.
     def build_table_header
-      output << "\t<table>\n"
-      unless data.column_names.empty? || !options.show_table_headers
-        output << "\t\t<tr>\n\t\t\t<th>" + 
-          data.column_names.join("</th>\n\t\t\t<th>") + 
-          "</th>\n\t\t</tr>\n"
-      end
+      output << build_header(options.show_table_headers ? data.column_names : nil)
     end
     
     # Uses the Row controller to build up the table body.
@@ -119,12 +114,19 @@ module Ruport
     end
     
     private
-    
+
+    def build_header(columns)
+      if !columns || columns.empty?
+        "\t<table>\n"
+      else
+        "\t<table>\n\t\t<thead>\n\t\t<tr>\n\t\t\t<th>" + 
+        columns.join("</th>\n\t\t\t<th>") + 
+        "</th>\n\t\t</tr>\n\t\t</thead>\n"
+      end
+    end
+
     def render_justified_grouping
-      output << "\t<table>\n\t\t<tr>\n\t\t\t<th>" +
-        "#{data.grouped_by}</th>\n\t\t\t<th>" +
-        grouping_columns.join("</th>\n\t\t\t<th>") + 
-        "</th>\n\t\t</tr>\n"
+      output << build_header(options.show_group_headers ? ([data.grouped_by] + grouping_columns) : nil)
       data.each do |name, group|                     
         group.each_with_index do |row, i|
           output << "\t\t<tr>\n\t\t\t"

data/lib/ruport/formatter/markdown.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Ruport
+  # This class produces Markdown table output from Ruport::Table data.
+  #
+  # === Rendering Options
+  # <tt>:alignment:</tt> Default alignment for all columns.
+  # Allowed values are :left, :center and :right. Default is :left.
+  #
+  # <tt>:column_alignments:</tt> Alignments for specific columns.
+  # You can configure alignments by using
+  # Hash (key: column name, value: alignment)
+  class Formatter::MarkDown < Formatter
+    renders :markdown, for: [Controller::Table]
+
+    # Hook for setting available options using a template.
+    def apply_template
+      apply_table_format_template(template.table)
+    end
+
+    # Uses the column names from the given Data::Table to generate
+    # a table header.
+    # If no column names are given, first row will be
+    # treated as table header.
+    def build_table_header
+      names = column_names(data)
+      build_md_row(output, names)
+      build_md_row(output, alignment_strings(names))
+    end
+
+    # Generates body of Markdown table data.
+    # Following characters will be replaced as escape.
+    #
+    # * | -> &#124;
+    # * newline code(\\n) -> \<br>
+    def build_table_body
+      body =
+        if data.column_names && !data.column_names.empty?
+          data
+        else
+          data[1..-1]
+        end
+      body.each { |row| build_md_row(output, row) }
+    end
+
+    private
+
+    def column_names(data)
+      if data.column_names && !data.column_names.empty?
+        data.column_names
+      else
+        data[0]
+      end
+    end
+
+    def build_md_row(output, row)
+      output << "|"
+      output << row.to_a.map { |cell| escape(cell.to_s.dup) }.join('|')
+      output << "|\n"
+    end
+
+    def escape(cell)
+      cell.gsub!("|", "&#124;")
+      cell.gsub!("\n", "<br>")
+      cell
+    end
+
+    def alignment_strings(column_names)
+      column_names.map(&method(:alignment_string))
+    end
+
+    def alignment_string(column_name)
+      case column_alignment(column_name)
+      when :right
+        "--:"
+      when :center
+        ":-:"
+      else
+        ":--"
+      end
+    end
+
+    def column_alignment(column_name)
+      if options.column_alignments && options.column_alignments.key?(column_name)
+        options.column_alignments[column_name]
+      elsif options.alignment
+        options.alignment
+      else
+        :left
+      end
+    end
+
+    def apply_table_format_template(template)
+      template = (template || {}).merge(options.table_format || {})
+      options.alignment ||= template[:alignment]
+      options.column_alignments =
+        merget_column_alignments(options, template)
+    end
+
+    def merget_column_alignments(options, template)
+      (template[:column_alignments] || {})
+        .merge(options.column_alignments || {})
+    end
+  end
+end

data/lib/ruport/formatter/prawn_pdf.rb

@@ -0,0 +1,159 @@
+module Ruport
+  class Formatter::PrawnPDF < Formatter
+
+    renders :prawn_pdf, :for =>[Controller::Row, Controller::Table,
+                              Controller::Group, Controller::Grouping]
+
+    attr_writer :pdf
+
+    def method_missing(id,*args, &block)
+      pdf.send(id,*args, &block)
+    end
+
+    def initialize
+      require 'prawn'
+      require 'prawn/table'
+    end
+
+    def pdf
+      @pdf ||= (options.formatter || 
+        ::Prawn::Document.new(options[:pdf_format] || {} ))
+    end
+
+    def draw_table(table, format_opts={}, &block)
+      m = "PDF Formatter requires column_names to be defined"
+      raise FormatterError, m if table.column_names.empty?
+
+      table.rename_columns { |c| c.to_s }
+
+      table_array = [table.column_names]
+      table_array += table_to_array(table)
+      table_array.map { |array| array.map! { |elem| elem.class != String ? elem.to_s : elem }}
+
+      if options[:table_format]
+        opt = options[:table_format] 
+      else
+        opt = format_opts
+      end
+
+      pdf.table(table_array, opt, &block)
+
+    end
+
+    def table_to_array(tbl)
+      tbl.map { |row| row.to_a}
+    end
+
+    def finalize
+      output << pdf.render
+    end
+
+    def build_table_body(&block)
+      draw_table(data, &block)
+    end
+
+    def build_group_body
+      render_table data, options.to_hash.merge(:formatter => pdf)
+    end
+
+    def build_grouping_body(&block)
+      data.each do |name,group|
+
+        # Group heading
+        move_down(20)
+        text name, :style => :bold, :size => 15
+
+        # Table
+        move_down(10)
+        draw_table group, &block
+      end
+    end
+
+    # Hook for setting available options using a template. See the template
+    # documentation for the available options and their format.
+    def apply_template
+      apply_page_format_template(template.page)
+      apply_text_format_template(template.text)
+      apply_table_format_template(template.table)
+      apply_column_format_template(template.column)
+      apply_heading_format_template(template.heading)
+      apply_grouping_format_template(template.grouping)
+    end
+
+    private
+
+    def apply_page_format_template(t)
+      options.pdf_format ||= {}
+      t = (t || {}).merge(options.page_format || {})
+      options.pdf_format[:page_size] ||= t[:size]
+      options.pdf_format[:page_layout] ||= t[:layout]
+    end
+
+    def apply_text_format_template(t)
+      t = (t || {}).merge(options.text_format || {})
+      options.text_format = t unless t.empty?
+    end
+
+    def apply_table_format_template(t)
+      t = (t || {}).merge(options.table_format || {})
+      options.table_format = t unless t.empty?
+    end
+
+    def apply_column_format_template(t)
+      t = (t || {}).merge(options.column_format || {})
+      column_opts = {}
+      column_opts.merge!(:justification => t[:alignment]) if t[:alignment]
+      column_opts.merge!(:width => t[:width]) if t[:width]
+      unless column_opts.empty?
+        if options.table_format
+          if options.table_format[:column_options]
+            options.table_format[:column_options] =
+              column_opts.merge(options.table_format[:column_options])
+          else
+            options.table_format.merge!(:column_options => column_opts)
+          end
+        else
+          options.table_format = { :column_options => column_opts }
+        end
+      end
+    end
+
+    def apply_heading_format_template(t)
+      t = (t || {}).merge(options.heading_format || {})
+      heading_opts = {}
+      heading_opts.merge!(:justification => t[:alignment]) if t[:alignment]
+      heading_opts.merge!(:bold => t[:bold]) unless t[:bold].nil?
+      heading_opts.merge!(:title => t[:title]) if t[:title]
+      unless heading_opts.empty?
+        if options.table_format
+          if options.table_format[:column_options]
+            if options.table_format[:column_options][:heading]
+              options.table_format[:column_options][:heading] =
+                heading_opts.merge(
+                  options.table_format[:column_options][:heading]
+                )
+            else
+              options.table_format[:column_options].merge!(
+                :heading => heading_opts
+              )
+            end
+          else
+            options.table_format.merge!(
+              :column_options => { :heading => heading_opts }
+            )
+          end
+        else
+          options.table_format = {
+            :column_options => { :heading => heading_opts }
+          }
+        end
+      end
+    end
+
+    def apply_grouping_format_template(t)
+      t = (t || {}).merge(options.grouping_format || {})
+      options.style ||= t[:style]
+    end
+
+  end
+end

data/lib/ruport/formatter/template.rb

@@ -140,7 +140,7 @@ class Ruport::Formatter::TemplateNotDefined < StandardError; end
 # 
 #   format_options  All options         Corresponding values
 #                   available to
-#                   FasterCSV.new
+#                   ::CSV.new
 #
 class Ruport::Formatter::Template < Ruport::Controller::Options
   

data/lib/ruport/formatter/text.rb

@@ -110,7 +110,7 @@ module Ruport
     def build_row(data = self.data)
       max_col_widths_for_row(data) unless options.max_col_width
 
-      data.enum_for(:each_with_index).inject(line=[]) { |s,e|
+      data.enum_for(:each_with_index).inject(line=[]) { |_s,e|
         field,index = e
         if options.alignment.eql? :center
           line << field.to_s.center(options.max_col_width[index])

data/lib/ruport/formatter.rb

@@ -1,73 +1,73 @@
-# Ruport : Extensible Reporting System                                
+# Ruport : Extensible Reporting System
 #
 # formatter.rb provides a generalized base class for creating ruport formatters.
-#     
+#
 # Created By Gregory Brown
-# Copyright (C) December 2006, All Rights Reserved.   
+# Copyright (C) December 2006, All Rights Reserved.
 #
 # This is free software distributed under the same terms as Ruby 1.8
 # See LICENSE and COPYING for details.
-module Ruport    
+module Ruport
   # Formatter is the base class for Ruport's format implementations.
   #
   # Typically, a Formatter will implement one or more output types,
-  # and be registered with one or more Controller classes. 
+  # and be registered with one or more Controller classes.
   #
   # This class provides all the necessary base functionality to make
   # use of Ruport's rendering system, including option handling, data
   # access, and basic output wrapping.
   #
   # The following example should provide a general idea of how formatters
-  # work, but see the built in formatters for reference implementations. 
-  # 
+  # work, but see the built in formatters for reference implementations.
+  #
   # A simple Controller definition is included to help show the example in
   # context, but you can also build your own custom interface to formatter
   # if you wish.
   #
   #   class ReverseController < Ruport::Controller
-  #      stage :reversed_header, :reversed_body 
+  #      stage :reversed_header, :reversed_body
   #   end
-  #                                            
-  #   class ReversedText < Ruport::Formatter 
-  #      
+  #
+  #   class ReversedText < Ruport::Formatter
+  #
   #      # Hooks formatter up to controller
-  #      renders :txt, :for => ReverseController      
-  #      
+  #      renders :txt, :for => ReverseController
+  #
   #      # Implements ReverseController's :reversed_header hook
-  #      # but can be used by any controller   
-  #      def build_reversed_header   
+  #      # but can be used by any controller
+  #      def build_reversed_header
   #         output << "#{options.header_text}\n"
   #         output << "The reversed text will follow\n"
-  #      end  
-  # 
+  #      end
+  #
   #      # Implements ReverseController's :reversed_body hook
   #      # but can be used by any controller
   #      def build_reversed_body
   #         output << data.reverse << "\n"
-  #      end         
+  #      end
   #
-  #   end    
+  #   end
   #
   #   puts ReverseController.render_txt(:data => "apple",
   #                                   :header_text => "Hello Mike, Hello Joe!")
-  #   
+  #
   #   -----
-  #   OUTPUT: 
-  # 
+  #   OUTPUT:
+  #
   #   Hello Mike, Hello Joe!
   #   The reversed text will follow
   #   elppa
-  #   
+  #
   class Formatter
-     
+
     # Provides shortcuts so that you can use Ruport's default rendering
-    # capabilities within your custom formatters   
+    # capabilities within your custom formatters
     #
     module RenderingTools
       # Uses Controller::Row to render the Row object with the
       # given options.
       #
-      # Sets the <tt>:io</tt> attribute by default to the existing 
+      # Sets the <tt>:io</tt> attribute by default to the existing
       # formatter's <tt>output</tt> object.
       def render_row(row,options={},&block)
         render_helper(Controller::Row,row,options,&block)
@@ -99,12 +99,12 @@ module Ruport
       def render_grouping(grouping,options={},&block)
         render_helper(Controller::Grouping,grouping,options,&block)
       end
-      
+
       # Iterates through the data in the grouping and renders each group
       # followed by a newline.
       #
       def render_inline_grouping(options={},&block)
-        data.each do |_,group|                     
+        data.each do |_,group|
           render_group(group, options, &block)
           output << "\n"
         end
@@ -113,11 +113,10 @@ module Ruport
       private
 
       def render_helper(rend_klass, source_data,options={},&block)
-        options = {:data => source_data, 
+        options = {:data => source_data,
                    :io => output,
-                   :layout => false }.merge(options)       
-                   
-        options[:io] = "" if self.class.kind_of?(Ruport::Formatter::PDF)
+                   :layout => false }.merge(options)
+
         rend_klass.render(format,options) do |rend|
           block[rend] if block
         end
@@ -126,13 +125,13 @@ module Ruport
     end
 
     include RenderingTools
-   
+
     # Set by the <tt>:data</tt> attribute from Controller#render
-    attr_reader :data              
-    
+    attr_reader :data
+
     # Set automatically by Controller#render(format) or Controller#render_format
-    attr_accessor :format                                                    
-    
+    attr_accessor :format
+
     # Set automatically by Controller#render as a Controller::Options object built
     # by the hash provided.
     attr_writer :options
@@ -145,24 +144,24 @@ module Ruport
     #
     def self.renders(fmts,options={})
       Array(fmts).each do |format|
-        Array(options[:for]).each do |o| 
-          o.send(:add_format,self,format) 
+        Array(options[:for]).each do |o|
+          o.send(:add_format,self,format)
           formats << format unless formats.include?(format)
-        end    
+        end
       end
     end
-    
+
     # Allows you to implement stages in your formatter using the
     # following syntax:
     #
-    #   class ReversedText < Ruport::Formatter 
+    #   class ReversedText < Ruport::Formatter
     #      renders :txt, :for => ReverseController
-    #      
+    #
     #      build :reversed_header do
     #         output << "#{options.header_text}\n"
     #         output << "The reversed text will follow\n"
     #      end
-    # 
+    #
     #      build :reversed_body do
     #         output << data.reverse << "\n"
     #      end
@@ -171,12 +170,12 @@ module Ruport
     def self.build(stage,&block)
       define_method "build_#{stage}", &block
     end
-    
+
     # Gives a list of formats registered for this formatter.
     def self.formats
       @formats ||= []
-    end   
-    
+    end
+
     # Returns the template currently set for this formatter.
     def template
       Template[options.template] rescue nil || Template[:default]
@@ -191,7 +190,7 @@ module Ruport
     # Provides a Controller::Options object for storing formatting options.
     def options
       @options ||= Controller::Options.new
-    end 
+    end
 
     # Sets the data object, making a local copy using #dup. This may have
     # a significant overhead for large tables, so formatters which don't
@@ -204,24 +203,24 @@ module Ruport
     def clear_output
       @output.replace("")
     end
-    
+
     # Saves the output to a file.
     def save_output(filename)
       File.open(filename,"w") {|f| f << output }
     end
-    
+
     # Use to define that your formatter should save in binary format
     def self.save_as_binary_file
       define_method :save_output do |filename|
         File.open(filename,"wb") {|f| f << output }
       end
     end
-    
+
     # Evaluates the string using ERB and returns the results.
     #
     # If <tt>:binding</tt> is specified, it will evaluate the template
     # in that context.
-    def erb(string,options={})      
+    def erb(string,options={})
       require "erb"
       if string =~ /(\.r\w+)|(\.erb)$/
         ERB.new(File.read(string)).result(options[:binding]||binding)
@@ -245,10 +244,11 @@ module Ruport
       end
     end
   end
-end                                
+end
 
 require "ruport/formatter/template"
 require "ruport/formatter/csv"
 require "ruport/formatter/html"
 require "ruport/formatter/text"
-require "ruport/formatter/pdf"
+require "ruport/formatter/prawn_pdf"
+require "ruport/formatter/markdown"

data/lib/ruport/version.rb

@@ -1,3 +1,3 @@
 module Ruport
-  VERSION = "1.6.3"
+  VERSION = "1.8.0"
 end

data/lib/ruport.rb

@@ -10,18 +10,6 @@
 # See LICENSE and COPYING for details
 #
  
-
-if RUBY_VERSION > "1.9"     
-  require "csv"   
-  unless defined? FCSV
-    class Object   
-      FCSV = CSV  
-      alias_method :FCSV, :CSV 
-    end   
-  end
-end
-
-
 module Ruport #:nodoc:#
   class FormatterError < RuntimeError #:nodoc:
   end
@@ -72,29 +60,26 @@ module Ruport #:nodoc:#
         stdout_handle = m_GetStdHandle.call(0xFFFFFFF5)
         
         m_GetConsoleScreenBufferInfo.call(stdout_handle, buf)
-        bufx, bufy, curx, cury, wattr,
-        left, top, right, bottom, maxx, maxy = buf.unpack(format)
+        _bufx, _bufy, _curx, _cury, _wattr, left, top, right, bottom, _maxx, _maxy = buf.unpack(format)
         return right - left + 1, bottom - top + 1
       end
     rescue LoadError             # If we're not on Windows try...
       # A Unix savvy method to fetch the console columns, and rows.
       def terminal_size
         size = if /solaris/ =~ RUBY_PLATFORM
-          output = `stty`
+          output = `stty 2>&1`
           [output.match('columns = (\d+)')[1].to_i,
           output.match('rows = (\d+)')[1].to_i]
         else
-           `stty size`.split.map { |x| x.to_i }.reverse
+           `stty size 2>&1`.split.map { |x| x.to_i }.reverse
         end 
         return $? == 0 ? size : [80,24] 
       end
-
-   end
+    end
    
-   def terminal_width
-     terminal_size.first
-   end
-
+    def terminal_width
+      terminal_size.first
+    end
   end
 
   # quiets warnings for block
@@ -111,7 +96,6 @@ module Ruport #:nodoc:#
 end  
 
 require "ruport/version"
-require "enumerator"
 require "ruport/controller" 
 require "ruport/data" 
 require "ruport/formatter"