jro_apps/redmine Commit - r10947:ff53a9cfe18d

Don't use Iconv with ruby1.9 (#12787)....

Jean-Philippe Lang -

r10947:ff53a9cfe18d

parent child

Context file:

r10947:ff53a9cfe18d

Collapse all files

lib/redmine/codeset_util.rb +14 -5

-            require 'iconv'
+            if RUBY_VERSION < '1.9'
+              require 'iconv'
+            end
             module Redmine
               module CodesetUtil
                 def self.replace_invalid_utf8(str)
                   return str if str.nil?
                   if str.respond_to?(:force_encoding)
                     str.force_encoding('UTF-8')
                     if ! str.valid_encoding?
                       str = str.encode("US-ASCII", :invalid => :replace,
                             :undef => :replace, :replace => '?').encode("UTF-8")
                     end
                   elsif RUBY_PLATFORM == 'java'
                     begin
                       ic = Iconv.new('UTF-8', 'UTF-8')
                       str = ic.iconv(str)
                     rescue
                       str = str.gsub(%r{[^\r\n\t\x20-\x7e]}, '?')
                     end
                   else
                     ic = Iconv.new('UTF-8', 'UTF-8')
                     txtar = ""
                     begin
                       txtar += ic.iconv(str)
                     rescue Iconv::IllegalSequence
                       txtar += $!.success
                       str = '?' + $!.failed[1,$!.failed.length]
                       retry
                     rescue
                       txtar += $!.success
                     end
                     str = txtar
                   end
                   str
                 end
                 def self.to_utf8(str, encoding)
                   return str if str.nil?
                   str.force_encoding("ASCII-8BIT") if str.respond_to?(:force_encoding)
                   if str.empty?
                     str.force_encoding("UTF-8") if str.respond_to?(:force_encoding)
                     return str
                   end
                   enc = encoding.blank? ? "UTF-8" : encoding
                   if str.respond_to?(:force_encoding)
                     if enc.upcase != "UTF-8"
                       str.force_encoding(enc)
                       str = str.encode("UTF-8", :invalid => :replace,
                             :undef => :replace, :replace => '?')
                     else
                       str.force_encoding("UTF-8")
                       if ! str.valid_encoding?
                         str = str.encode("US-ASCII", :invalid => :replace,
                               :undef => :replace, :replace => '?').encode("UTF-8")
                       end
                     end
                   elsif RUBY_PLATFORM == 'java'
                     begin
                       ic = Iconv.new('UTF-8', enc)
                       str = ic.iconv(str)
                     rescue
                       str = str.gsub(%r{[^\r\n\t\x20-\x7e]}, '?')
                     end
                   else
                     ic = Iconv.new('UTF-8', enc)
                     txtar = ""
                     begin
                       txtar += ic.iconv(str)
                     rescue Iconv::IllegalSequence
                       txtar += $!.success
                       str = '?' + $!.failed[1,$!.failed.length]
                       retry
                     rescue
                       txtar += $!.success
                     end
                     str = txtar
                   end
                   str
                 end
                 def self.to_utf8_by_setting(str)
                   return str if str.nil?
                   str = self.to_utf8_by_setting_internal(str)
                   if str.respond_to?(:force_encoding)
                     str.force_encoding('UTF-8')
                   end
                   str
                 end
                 def self.to_utf8_by_setting_internal(str)
                   return str if str.nil?
                   if str.respond_to?(:force_encoding)
                     str.force_encoding('ASCII-8BIT')
                   end
                   return str if str.empty?
                   return str if /\A[\r\n\t\x20-\x7e]*\Z/n.match(str) # for us-ascii
                   if str.respond_to?(:force_encoding)
                     str.force_encoding('UTF-8')
                   end
                   encodings = Setting.repositories_encodings.split(',').collect(&:strip)
                   encodings.each do |encoding|
-                    begin
+                    if str.respond_to?(:force_encoding)
-                      return Iconv.conv('UTF-8', encoding, str)
+                      str.force_encoding(encoding)
-                    rescue Iconv::Failure
+                      if str.valid_encoding?
-                      # do nothing here and try the next encoding
+                        return str.encode('UTF-8')
+                      end
+                    else
+                      begin
+                        return Iconv.conv('UTF-8', encoding, str)
+                      rescue Iconv::Failure
+                        # do nothing here and try the next encoding
+                      end
                     end
                   end
                   str = self.replace_invalid_utf8(str)
                   if str.respond_to?(:force_encoding)
                     str.force_encoding('UTF-8')
                   end
                   str
                 end
                 def self.from_utf8(str, encoding)
                   str ||= ''
                   if str.respond_to?(:force_encoding)
                     str.force_encoding('UTF-8')
                     if encoding.upcase != 'UTF-8'
                       str = str.encode(encoding, :invalid => :replace,
                                        :undef => :replace, :replace => '?')
                     else
                       str = self.replace_invalid_utf8(str)
                     end
                   elsif RUBY_PLATFORM == 'java'
                     begin
                       ic = Iconv.new(encoding, 'UTF-8')
                       str = ic.iconv(str)
                     rescue
                       str = str.gsub(%r{[^\r\n\t\x20-\x7e]}, '?')
                     end
                   else
                     ic = Iconv.new(encoding, 'UTF-8')
                     txtar = ""
                     begin
                       txtar += ic.iconv(str)
                     rescue Iconv::IllegalSequence
                       txtar += $!.success
                       str = '?' + $!.failed[1, $!.failed.length]
                       retry
                     rescue
                       txtar += $!.success
                     end
                     str = txtar
                   end
                 end
               end
             end

lib/redmine/export/pdf.rb +15 -3

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-            require 'iconv'
             require 'tcpdf'
             require 'fpdf/chinese'
             require 'fpdf/japanese'
             require 'fpdf/korean'
+            if RUBY_VERSION < '1.9'
+              require 'iconv'
+            end
             module Redmine
               module Export
                 module PDF
                   include ActionView::Helpers::TextHelper
                   include ActionView::Helpers::NumberHelper
                   include IssuesHelper
                   class ITCPDF < TCPDF
                     include Redmine::I18n
                     attr_accessor :footer_date
                     def initialize(lang, orientation='P')
                       @@k_path_cache = Rails.root.join('tmp', 'pdf')
                       FileUtils.mkdir_p @@k_path_cache unless File::exist?(@@k_path_cache)
                       set_language_if_valid lang
                       pdf_encoding = l(:general_pdf_encoding).upcase
                       super(orientation, 'mm', 'A4', (pdf_encoding == 'UTF-8'), pdf_encoding)
                       case current_language.to_s.downcase
                       when 'vi'
                         @font_for_content = 'DejaVuSans'
                         @font_for_footer  = 'DejaVuSans'
                       else
                         case pdf_encoding
                         when 'UTF-8'
                           @font_for_content = 'FreeSans'
                           @font_for_footer  = 'FreeSans'
                         when 'CP949'
                           extend(PDF_Korean)
                           AddUHCFont()
                           @font_for_content = 'UHC'
                           @font_for_footer  = 'UHC'
                         when 'CP932', 'SJIS', 'SHIFT_JIS'
                           extend(PDF_Japanese)
                           AddSJISFont()
                           @font_for_content = 'SJIS'
                           @font_for_footer  = 'SJIS'
                         when 'GB18030'
                           extend(PDF_Chinese)
                           AddGBFont()
                           @font_for_content = 'GB'
                           @font_for_footer  = 'GB'
                         when 'BIG5'
                           extend(PDF_Chinese)
                           AddBig5Font()
                           @font_for_content = 'Big5'
                           @font_for_footer  = 'Big5'
                         else
                           @font_for_content = 'Arial'
                           @font_for_footer  = 'Helvetica'
                         end
                       end
                       SetCreator(Redmine::Info.app_name)
                       SetFont(@font_for_content)
                       @outlines = []
                       @outlineRoot = nil
                     end
                     def SetFontStyle(style, size)
                       SetFont(@font_for_content, style, size)
                     end
                     def SetTitle(txt)
                       txt = begin
-                        utf16txt = Iconv.conv('UTF-16BE', 'UTF-8', txt)
+                        utf16txt = to_utf16(txt)
                         hextxt = "<FEFF"  # FEFF is BOM
                         hextxt << utf16txt.unpack("C*").map {|x| sprintf("%02X",x) }.join
                         hextxt << ">"
                       rescue
                         txt
                       end || ''
                       super(txt)
                     end
                     def textstring(s)
                       # Format a text string
                       if s =~ /^</  # This means the string is hex-dumped.
                         return s
                       else
                         return '('+escape(s)+')'
                       end
                     end
                     def fix_text_encoding(txt)
                       RDMPdfEncoding::rdm_from_utf8(txt, l(:general_pdf_encoding))
                     end
+                    # Encodes an UTF-8 string to UTF-16BE
+                    def to_utf16(str)
+                      if str.respond_to?(:encode)
+                        str.encode('UTF-16BE')
+                      else
+                        Iconv.conv('UTF-16BE', 'UTF-8', str)
+                      end
+                    end
                     def RDMCell(w ,h=0, txt='', border=0, ln=0, align='', fill=0, link='')
                       Cell(w, h, fix_text_encoding(txt), border, ln, align, fill, link)
                     end
                     def RDMMultiCell(w, h=0, txt='', border=0, align='', fill=0, ln=1)
                       MultiCell(w, h, fix_text_encoding(txt), border, align, fill, ln)
                     end
                     def RDMwriteHTMLCell(w, h, x, y, txt='', attachments=[], border=0, ln=1, fill=0)
                       @attachments = attachments
                       writeHTMLCell(w, h, x, y,
                         fix_text_encoding(
                           Redmine::WikiFormatting.to_html(Setting.text_formatting, txt)),
                         border, ln, fill)
                     end
                     def getImageFilename(attrname)
                       # attrname: general_pdf_encoding string file/uri name
                       atta = RDMPdfEncoding.attach(@attachments, attrname, l(:general_pdf_encoding))
                       if atta
                         return atta.diskfile
                       else
                         return nil
                       end
                     end
                     def Footer
                       SetFont(@font_for_footer, 'I', 8)
                       SetY(-15)
                       SetX(15)
                       RDMCell(0, 5, @footer_date, 0, 0, 'L')
                       SetY(-15)
                       SetX(-30)
                       RDMCell(0, 5, PageNo().to_s + '/{nb}', 0, 0, 'C')
                     end
                     def Bookmark(txt, level=0, y=0)
                       if (y == -1)
                         y = GetY()
                       end
                       @outlines << {:t => txt, :l => level, :p => PageNo(), :y => (@h - y)*@k}
                     end
                     def bookmark_title(txt)
                       txt = begin
-                        utf16txt = Iconv.conv('UTF-16BE', 'UTF-8', txt)
+                        utf16txt = to_utf16(txt)
                         hextxt = "<FEFF"  # FEFF is BOM
                         hextxt << utf16txt.unpack("C*").map {|x| sprintf("%02X",x) }.join
                         hextxt << ">"
                       rescue
                         txt
                       end || ''
                     end
                     def putbookmarks
                       nb=@outlines.size
                       return if (nb==0)
                       lru=[]
                       level=0
                       @outlines.each_with_index do |o, i|
                         if(o[:l]>0)
                           parent=lru[o[:l]-1]
                           #Set parent and last pointers
                           @outlines[i][:parent]=parent
                           @outlines[parent][:last]=i
                           if (o[:l]>level)
                             #Level increasing: set first pointer
                             @outlines[parent][:first]=i
                           end
                         else
                           @outlines[i][:parent]=nb
                         end
                         if (o[:l]<=level && i>0)
                           #Set prev and next pointers
                           prev=lru[o[:l]]
                           @outlines[prev][:next]=i
                           @outlines[i][:prev]=prev
                         end
                         lru[o[:l]]=i
                         level=o[:l]
                       end
                       #Outline items
                       n=self.n+1
                       @outlines.each_with_index do |o, i|
                         newobj()
                         out('<</Title '+bookmark_title(o[:t]))
                         out("/Parent #{n+o[:parent]} 0 R")
                         if (o[:prev])
                           out("/Prev #{n+o[:prev]} 0 R")
                         end
                         if (o[:next])
                           out("/Next #{n+o[:next]} 0 R")
                         end
                         if (o[:first])
                           out("/First #{n+o[:first]} 0 R")
                         end
                         if (o[:last])
                           out("/Last #{n+o[:last]} 0 R")
                         end
                         out("/Dest [%d 0 R /XYZ 0 %.2f null]" % [1+2*o[:p], o[:y]])
                         out('/Count 0>>')
                         out('endobj')
                       end
                       #Outline root
                       newobj()
                       @outlineRoot=self.n
                       out("<</Type /Outlines /First #{n} 0 R");
                       out("/Last #{n+lru[0]} 0 R>>");
                       out('endobj');
                     end
                     def putresources()
                       super
                       putbookmarks()
                     end
                     def putcatalog()
                       super
                       if(@outlines.size > 0)
                         out("/Outlines #{@outlineRoot} 0 R");
                         out('/PageMode /UseOutlines');
                       end
                     end
                   end
                   # fetch row values
                   def fetch_row_values(issue, query, level)
                     query.inline_columns.collect do |column|
                       s = if column.is_a?(QueryCustomFieldColumn)
                         cv = issue.custom_field_values.detect {|v| v.custom_field_id == column.custom_field.id}
                         show_value(cv)
                       else
                         value = issue.send(column.name)
                         if column.name == :subject
                           value = "  " * level + value
                         end
                         if value.is_a?(Date)
                           format_date(value)
                         elsif value.is_a?(Time)
                           format_time(value)
                         else
                           value
                         end
                       end
                       s.to_s
                     end
                   end
                   # calculate columns width
                   def calc_col_width(issues, query, table_width, pdf)
                     # calculate statistics
                     #  by captions
                     pdf.SetFontStyle('B',8)
                     col_padding = pdf.GetStringWidth('OO')
                     col_width_min = query.inline_columns.map {|v| pdf.GetStringWidth(v.caption) + col_padding}
                     col_width_max = Array.new(col_width_min)
                     col_width_avg = Array.new(col_width_min)
                     word_width_max = query.inline_columns.map {|c|
                       n = 10
                       c.caption.split.each {|w|
                         x = pdf.GetStringWidth(w) + col_padding
                         n = x if n < x
                       }
                       n
                     }
                     #  by properties of issues
                     pdf.SetFontStyle('',8)
                     col_padding = pdf.GetStringWidth('OO')
                     k = 1
                     issue_list(issues) {|issue, level|
                       k += 1
                       values = fetch_row_values(issue, query, level)
                       values.each_with_index {|v,i|
                         n = pdf.GetStringWidth(v) + col_padding
                         col_width_max[i] = n if col_width_max[i] < n
                         col_width_min[i] = n if col_width_min[i] > n
                         col_width_avg[i] += n
                         v.split.each {|w|
                           x = pdf.GetStringWidth(w) + col_padding
                           word_width_max[i] = x if word_width_max[i] < x
                         }
                       }
                     }
                     col_width_avg.map! {|x| x / k}
                     # calculate columns width
                     ratio = table_width / col_width_avg.inject(0) {|s,w| s += w}
                     col_width = col_width_avg.map {|w| w * ratio}
                     # correct max word width if too many columns
                     ratio = table_width / word_width_max.inject(0) {|s,w| s += w}
                     word_width_max.map! {|v| v * ratio} if ratio < 1
                     # correct and lock width of some columns
                     done = 1
                     col_fix = []
                     col_width.each_with_index do |w,i|
                       if w > col_width_max[i]
                         col_width[i] = col_width_max[i]
                         col_fix[i] = 1
                         done = 0
                       elsif w < word_width_max[i]
                         col_width[i] = word_width_max[i]
                         col_fix[i] = 1
                         done = 0
                       else
                         col_fix[i] = 0
                       end
                     end
                     # iterate while need to correct and lock coluns width
                     while done == 0
                       # calculate free & locked columns width
                       done = 1
                       fix_col_width = 0
                       free_col_width = 0
                       col_width.each_with_index do |w,i|
                         if col_fix[i] == 1
                           fix_col_width += w
                         else
                           free_col_width += w
                         end
                       end
                       # calculate column normalizing ratio
                       if free_col_width == 0
                         ratio = table_width / col_width.inject(0) {|s,w| s += w}
                       else
                         ratio = (table_width - fix_col_width) / free_col_width
                       end
                       # correct columns width
                       col_width.each_with_index do |w,i|
                         if col_fix[i] == 0
                           col_width[i] = w * ratio
                           # check if column width less then max word width
                           if col_width[i] < word_width_max[i]
                             col_width[i] = word_width_max[i]
                             col_fix[i] = 1
                             done = 0
                           elsif col_width[i] > col_width_max[i]
                             col_width[i] = col_width_max[i]
                             col_fix[i] = 1
                             done = 0
                           end
                         end
                       end
                     end
                     col_width
                   end
                   def render_table_header(pdf, query, col_width, row_height, col_id_width, table_width)
                     # headers
                     pdf.SetFontStyle('B',8)
                     pdf.SetFillColor(230, 230, 230)
                     # render it background to find the max height used
                     base_x = pdf.GetX
                     base_y = pdf.GetY
                     max_height = issues_to_pdf_write_cells(pdf, query.inline_columns, col_width, row_height, true)
                     pdf.Rect(base_x, base_y, table_width + col_id_width, max_height, 'FD');
                     pdf.SetXY(base_x, base_y);
                     # write the cells on page
                     pdf.RDMCell(col_id_width, row_height, "#", "T", 0, 'C', 1)
                     issues_to_pdf_write_cells(pdf, query.inline_columns, col_width, row_height, true)
                     issues_to_pdf_draw_borders(pdf, base_x, base_y, base_y + max_height, col_id_width, col_width)
                     pdf.SetY(base_y + max_height);
                     # rows
                     pdf.SetFontStyle('',8)
                     pdf.SetFillColor(255, 255, 255)
                   end
                   # Returns a PDF string of a list of issues
                   def issues_to_pdf(issues, project, query)
                     pdf = ITCPDF.new(current_language, "L")
                     title = query.new_record? ? l(:label_issue_plural) : query.name
                     title = "#{project} - #{title}" if project
                     pdf.SetTitle(title)
                     pdf.alias_nb_pages
                     pdf.footer_date = format_date(Date.today)
                     pdf.SetAutoPageBreak(false)
                     pdf.AddPage("L")
                     # Landscape A4 = 210 x 297 mm
                     page_height   = 210
                     page_width    = 297
                     right_margin  = 10
                     bottom_margin = 20
                     col_id_width  = 10
                     row_height    = 4
                     # column widths
                     table_width = page_width - right_margin - 10  # fixed left margin
                     col_width = []
                     unless query.inline_columns.empty?
                       col_width = calc_col_width(issues, query, table_width - col_id_width, pdf)
                       table_width = col_width.inject(0) {|s,v| s += v}
                     end
             				# use full width if the description is displayed
                     if table_width > 0 && query.has_column?(:description)
                       col_width = col_width.map {|w| w = w * (page_width - right_margin - 10 - col_id_width) / table_width}
                       table_width = col_width.inject(0) {|s,v| s += v}
                     end
                     # title
                     pdf.SetFontStyle('B',11)
                     pdf.RDMCell(190,10, title)
                     pdf.Ln
                     render_table_header(pdf, query, col_width, row_height, col_id_width, table_width)
                     previous_group = false
                     issue_list(issues) do |issue, level|
                       if query.grouped? &&
                            (group = query.group_by_column.value(issue)) != previous_group
                         pdf.SetFontStyle('B',10)
                         group_label = group.blank? ? 'None' : group.to_s.dup
                         group_label << " (#{query.issue_count_by_group[group]})"
                         pdf.Bookmark group_label, 0, -1
                         pdf.RDMCell(table_width + col_id_width, row_height * 2, group_label, 1, 1, 'L')
                         pdf.SetFontStyle('',8)
                         previous_group = group
                       end
                       # fetch row values
                       col_values = fetch_row_values(issue, query, level)
                       # render it off-page to find the max height used
                       base_x = pdf.GetX
                       base_y = pdf.GetY
                       pdf.SetY(2 * page_height)
                       max_height = issues_to_pdf_write_cells(pdf, col_values, col_width, row_height)
                       pdf.SetXY(base_x, base_y)
                       # make new page if it doesn't fit on the current one
                       space_left = page_height - base_y - bottom_margin
                       if max_height > space_left
                         pdf.AddPage("L")
                         render_table_header(pdf, query, col_width, row_height, col_id_width, table_width)
                         base_x = pdf.GetX
                         base_y = pdf.GetY
                       end
                       # write the cells on page
                       pdf.RDMCell(col_id_width, row_height, issue.id.to_s, "T", 0, 'C', 1)
                       issues_to_pdf_write_cells(pdf, col_values, col_width, row_height)
                       issues_to_pdf_draw_borders(pdf, base_x, base_y, base_y + max_height, col_id_width, col_width)
                       pdf.SetY(base_y + max_height);
                       if query.has_column?(:description) && issue.description?
                         pdf.SetX(10)
                         pdf.SetAutoPageBreak(true, 20)
                         pdf.RDMwriteHTMLCell(0, 5, 10, 0, issue.description.to_s, issue.attachments, "LRBT")
                         pdf.SetAutoPageBreak(false)
                       end
                     end
                     if issues.size == Setting.issues_export_limit.to_i
                       pdf.SetFontStyle('B',10)
                       pdf.RDMCell(0, row_height, '...')
                     end
                     pdf.Output
                   end
                   # Renders MultiCells and returns the maximum height used
                   def issues_to_pdf_write_cells(pdf, col_values, col_widths,
                                                 row_height, head=false)
                     base_y = pdf.GetY
                     max_height = row_height
                     col_values.each_with_index do |column, i|
                       col_x = pdf.GetX
                       if head == true
                         pdf.RDMMultiCell(col_widths[i], row_height, column.caption, "T", 'L', 1)
                       else
                         pdf.RDMMultiCell(col_widths[i], row_height, column, "T", 'L', 1)
                       end
                       max_height = (pdf.GetY - base_y) if (pdf.GetY - base_y) > max_height
                       pdf.SetXY(col_x + col_widths[i], base_y);
                     end
                     return max_height
                   end
                   # Draw lines to close the row (MultiCell border drawing in not uniform)
                   def issues_to_pdf_draw_borders(pdf, top_x, top_y, lower_y,
                                                  id_width, col_widths)
                     col_x = top_x + id_width
                     pdf.Line(col_x, top_y, col_x, lower_y)    # id right border
                     col_widths.each do |width|
                       col_x += width
                       pdf.Line(col_x, top_y, col_x, lower_y)  # columns right border
                     end
                     pdf.Line(top_x, top_y, top_x, lower_y)    # left border
                     pdf.Line(top_x, lower_y, col_x, lower_y)  # bottom border
                   end
                   # Returns a PDF string of a single issue
                   def issue_to_pdf(issue, assoc={})
                     pdf = ITCPDF.new(current_language)
                     pdf.SetTitle("#{issue.project} - #{issue.tracker} ##{issue.id}")
                     pdf.alias_nb_pages
                     pdf.footer_date = format_date(Date.today)
                     pdf.AddPage
                     pdf.SetFontStyle('B',11)
                     buf = "#{issue.project} - #{issue.tracker} ##{issue.id}"
                     pdf.RDMMultiCell(190, 5, buf)
                     pdf.SetFontStyle('',8)
                     base_x = pdf.GetX
                     i = 1
                     issue.ancestors.visible.each do |ancestor|
                       pdf.SetX(base_x + i)
                       buf = "#{ancestor.tracker} # #{ancestor.id} (#{ancestor.status.to_s}): #{ancestor.subject}"
                       pdf.RDMMultiCell(190 - i, 5, buf)
                       i += 1 if i < 35
                     end
                     pdf.SetFontStyle('B',11)
                     pdf.RDMMultiCell(190 - i, 5, issue.subject.to_s)
                     pdf.SetFontStyle('',8)
                     pdf.RDMMultiCell(190, 5, "#{format_time(issue.created_on)} - #{issue.author}")
                     pdf.Ln
                     left = []
                     left << [l(:field_status), issue.status]
                     left << [l(:field_priority), issue.priority]
                     left << [l(:field_assigned_to), issue.assigned_to] unless issue.disabled_core_fields.include?('assigned_to_id')
                     left << [l(:field_category), issue.category] unless issue.disabled_core_fields.include?('category_id')
                     left << [l(:field_fixed_version), issue.fixed_version] unless issue.disabled_core_fields.include?('fixed_version_id')
                     right = []
                     right << [l(:field_start_date), format_date(issue.start_date)] unless issue.disabled_core_fields.include?('start_date')
                     right << [l(:field_due_date), format_date(issue.due_date)] unless issue.disabled_core_fields.include?('due_date')
                     right << [l(:field_done_ratio), "#{issue.done_ratio}%"] unless issue.disabled_core_fields.include?('done_ratio')
                     right << [l(:field_estimated_hours), l_hours(issue.estimated_hours)] unless issue.disabled_core_fields.include?('estimated_hours')
                     right << [l(:label_spent_time), l_hours(issue.total_spent_hours)] if User.current.allowed_to?(:view_time_entries, issue.project)
                     rows = left.size > right.size ? left.size : right.size
                     while left.size < rows
                       left << nil
                     end
                     while right.size < rows
                       right << nil
                     end
                     half = (issue.custom_field_values.size / 2.0).ceil
                     issue.custom_field_values.each_with_index do |custom_value, i|
                       (i < half ? left : right) << [custom_value.custom_field.name, show_value(custom_value)]
                     end
                     rows = left.size > right.size ? left.size : right.size
                     rows.times do |i|
                       item = left[i]
                       pdf.SetFontStyle('B',9)
                       pdf.RDMCell(35,5, item ? "#{item.first}:" : "", i == 0 ? "LT" : "L")
                       pdf.SetFontStyle('',9)
                       pdf.RDMCell(60,5, item ? item.last.to_s : "", i == 0 ? "RT" : "R")
                       item = right[i]
                       pdf.SetFontStyle('B',9)
                       pdf.RDMCell(35,5, item ? "#{item.first}:" : "", i == 0 ? "LT" : "L")
                       pdf.SetFontStyle('',9)
                       pdf.RDMCell(60,5, item ? item.last.to_s : "", i == 0 ? "RT" : "R")
                       pdf.Ln
                     end
                     pdf.SetFontStyle('B',9)
                     pdf.RDMCell(35+155, 5, l(:field_description), "LRT", 1)
                     pdf.SetFontStyle('',9)
                     # Set resize image scale
                     pdf.SetImageScale(1.6)
                     pdf.RDMwriteHTMLCell(35+155, 5, 0, 0,
                           issue.description.to_s, issue.attachments, "LRB")
                     unless issue.leaf?
                       # for CJK
                       truncate_length = ( l(:general_pdf_encoding).upcase == "UTF-8" ? 90 : 65 )
                       pdf.SetFontStyle('B',9)
                       pdf.RDMCell(35+155,5, l(:label_subtask_plural) + ":", "LTR")
                       pdf.Ln
                       issue_list(issue.descendants.visible.sort_by(&:lft)) do |child, level|
                         buf = truncate("#{child.tracker} # #{child.id}: #{child.subject}",
                                        :length => truncate_length)
                         level = 10 if level >= 10
                         pdf.SetFontStyle('',8)
                         pdf.RDMCell(35+135,5, (level >=1 ? "  " * level : "") + buf, "L")
                         pdf.SetFontStyle('B',8)
                         pdf.RDMCell(20,5, child.status.to_s, "R")
                         pdf.Ln
                       end
                     end
                     relations = issue.relations.select { |r| r.other_issue(issue).visible? }
                     unless relations.empty?
                       # for CJK
                       truncate_length = ( l(:general_pdf_encoding).upcase == "UTF-8" ? 80 : 60 )
                       pdf.SetFontStyle('B',9)
                       pdf.RDMCell(35+155,5, l(:label_related_issues) + ":", "LTR")
                       pdf.Ln
                       relations.each do |relation|
                         buf = ""
                         buf += "#{l(relation.label_for(issue))} "
                         if relation.delay && relation.delay != 0
                           buf += "(#{l('datetime.distance_in_words.x_days', :count => relation.delay)}) "
                         end
                         if Setting.cross_project_issue_relations?
                           buf += "#{relation.other_issue(issue).project} - "
                         end
                         buf += "#{relation.other_issue(issue).tracker}" +
                                " # #{relation.other_issue(issue).id}: #{relation.other_issue(issue).subject}"
                         buf = truncate(buf, :length => truncate_length)
                         pdf.SetFontStyle('', 8)
                         pdf.RDMCell(35+155-60, 5, buf, "L")
                         pdf.SetFontStyle('B',8)
                         pdf.RDMCell(20,5, relation.other_issue(issue).status.to_s, "")
                         pdf.RDMCell(20,5, format_date(relation.other_issue(issue).start_date), "")
                         pdf.RDMCell(20,5, format_date(relation.other_issue(issue).due_date), "R")
                         pdf.Ln
                       end
                     end
                     pdf.RDMCell(190,5, "", "T")
                     pdf.Ln
                     if issue.changesets.any? &&
                          User.current.allowed_to?(:view_changesets, issue.project)
                       pdf.SetFontStyle('B',9)
                       pdf.RDMCell(190,5, l(:label_associated_revisions), "B")
                       pdf.Ln
                       for changeset in issue.changesets
                         pdf.SetFontStyle('B',8)
                         csstr  = "#{l(:label_revision)} #{changeset.format_identifier} - "
                         csstr += format_time(changeset.committed_on) + " - " + changeset.author.to_s
                         pdf.RDMCell(190, 5, csstr)
                         pdf.Ln
                         unless changeset.comments.blank?
                           pdf.SetFontStyle('',8)
                           pdf.RDMwriteHTMLCell(190,5,0,0,
                                 changeset.comments.to_s, issue.attachments, "")
                         end
                         pdf.Ln
                       end
                     end
                     if assoc[:journals].present?
                       pdf.SetFontStyle('B',9)
                       pdf.RDMCell(190,5, l(:label_history), "B")
                       pdf.Ln
                       assoc[:journals].each do |journal|
                         pdf.SetFontStyle('B',8)
                         title = "##{journal.indice} - #{format_time(journal.created_on)} - #{journal.user}"
                         title << " (#{l(:field_private_notes)})" if journal.private_notes?
                         pdf.RDMCell(190,5, title)
                         pdf.Ln
                         pdf.SetFontStyle('I',8)
                         details_to_strings(journal.details, true).each do |string|
                           pdf.RDMMultiCell(190,5, "- " + string)
                         end
                         if journal.notes?
                           pdf.Ln unless journal.details.empty?
                           pdf.SetFontStyle('',8)
                           pdf.RDMwriteHTMLCell(190,5,0,0,
                                 journal.notes.to_s, issue.attachments, "")
                         end
                         pdf.Ln
                       end
                     end
                     if issue.attachments.any?
                       pdf.SetFontStyle('B',9)
                       pdf.RDMCell(190,5, l(:label_attachment_plural), "B")
                       pdf.Ln
                       for attachment in issue.attachments
                         pdf.SetFontStyle('',8)
                         pdf.RDMCell(80,5, attachment.filename)
                         pdf.RDMCell(20,5, number_to_human_size(attachment.filesize),0,0,"R")
                         pdf.RDMCell(25,5, format_date(attachment.created_on),0,0,"R")
                         pdf.RDMCell(65,5, attachment.author.name,0,0,"R")
                         pdf.Ln
                       end
                     end
                     pdf.Output
                   end
                   # Returns a PDF string of a set of wiki pages
                   def wiki_pages_to_pdf(pages, project)
                     pdf = ITCPDF.new(current_language)
                     pdf.SetTitle(project.name)
                     pdf.alias_nb_pages
                     pdf.footer_date = format_date(Date.today)
                     pdf.AddPage
                     pdf.SetFontStyle('B',11)
                     pdf.RDMMultiCell(190,5, project.name)
                     pdf.Ln
                     # Set resize image scale
                     pdf.SetImageScale(1.6)
                     pdf.SetFontStyle('',9)
                     write_page_hierarchy(pdf, pages.group_by(&:parent_id))
                     pdf.Output
                   end
                   # Returns a PDF string of a single wiki page
                   def wiki_page_to_pdf(page, project)
                     pdf = ITCPDF.new(current_language)
                     pdf.SetTitle("#{project} - #{page.title}")
                     pdf.alias_nb_pages
                     pdf.footer_date = format_date(Date.today)
                     pdf.AddPage
                     pdf.SetFontStyle('B',11)
                     pdf.RDMMultiCell(190,5,
                          "#{project} - #{page.title} - # #{page.content.version}")
                     pdf.Ln
                     # Set resize image scale
                     pdf.SetImageScale(1.6)
                     pdf.SetFontStyle('',9)
                     write_wiki_page(pdf, page)
                     pdf.Output
                   end
                   def write_page_hierarchy(pdf, pages, node=nil, level=0)
                     if pages[node]
                       pages[node].each do |page|
                         if @new_page
                           pdf.AddPage
                         else
                           @new_page = true
                         end
                         pdf.Bookmark page.title, level
                         write_wiki_page(pdf, page)
                         write_page_hierarchy(pdf, pages, page.id, level + 1) if pages[page.id]
                       end
                     end
                   end
                   def write_wiki_page(pdf, page)
                     pdf.RDMwriteHTMLCell(190,5,0,0,
                           page.content.text.to_s, page.attachments, 0)
                     if page.attachments.any?
                       pdf.Ln
                       pdf.SetFontStyle('B',9)
                       pdf.RDMCell(190,5, l(:label_attachment_plural), "B")
                       pdf.Ln
                       for attachment in page.attachments
                         pdf.SetFontStyle('',8)
                         pdf.RDMCell(80,5, attachment.filename)
                         pdf.RDMCell(20,5, number_to_human_size(attachment.filesize),0,0,"R")
                         pdf.RDMCell(25,5, format_date(attachment.created_on),0,0,"R")
                         pdf.RDMCell(65,5, attachment.author.name,0,0,"R")
                         pdf.Ln
                       end
                     end
                   end
                   class RDMPdfEncoding
                     def self.rdm_from_utf8(txt, encoding)
                       txt ||= ''
                       txt = Redmine::CodesetUtil.from_utf8(txt, encoding)
                       if txt.respond_to?(:force_encoding)
                         txt.force_encoding('ASCII-8BIT')
                       end
                       txt
                     end
                     def self.attach(attachments, filename, encoding)
                       filename_utf8 = Redmine::CodesetUtil.to_utf8(filename, encoding)
                       atta = nil
                       if filename_utf8 =~ /^[^\/"]+\.(gif|jpg|jpe|jpeg|png)$/i
                         atta = Attachment.latest_attach(attachments, filename_utf8)
                       end
                       if atta && atta.readable? && atta.visible?
                         return atta
                       else
                         return nil
                       end
                     end
                   end
                 end
               end
             end

lib/redmine/scm/adapters/abstract_adapter.rb +4 0

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'cgi'
+            if RUBY_VERSION < '1.9'
+              require 'iconv'
+            end
             module Redmine
               module Scm
                 module Adapters
                   class CommandFailed < StandardError #:nodoc:
                   end
                   class AbstractAdapter #:nodoc:
                     # raised if scm command exited with error, e.g. unknown revision.
                     class ScmCommandAborted < CommandFailed; end
                     class << self
                       def client_command
                         ""
                       end
                       def shell_quote_command
                         if Redmine::Platform.mswin? && RUBY_PLATFORM == 'java'
                           client_command
                         else
                           shell_quote(client_command)
                         end
                       end
                       # Returns the version of the scm client
                       # Eg: [1, 5, 0] or [] if unknown
                       def client_version
                         []
                       end
                       # Returns the version string of the scm client
                       # Eg: '1.5.0' or 'Unknown version' if unknown
                       def client_version_string
                         v = client_version || 'Unknown version'
                         v.is_a?(Array) ? v.join('.') : v.to_s
                       end
                       # Returns true if the current client version is above
                       # or equals the given one
                       # If option is :unknown is set to true, it will return
                       # true if the client version is unknown
                       def client_version_above?(v, options={})
                         ((client_version <=> v) >= 0) || (client_version.empty? && options[:unknown])
                       end
                       def client_available
                         true
                       end
                       def shell_quote(str)
                         if Redmine::Platform.mswin?
                           '"' + str.gsub(/"/, '\\"') + '"'
                         else
                           "'" + str.gsub(/'/, "'\"'\"'") + "'"
                         end
                       end
                     end
                     def initialize(url, root_url=nil, login=nil, password=nil,
                                    path_encoding=nil)
                       @url = url
                       @login = login if login && !login.empty?
                       @password = (password || "") if @login
                       @root_url = root_url.blank? ? retrieve_root_url : root_url
                     end
                     def adapter_name
                       'Abstract'
                     end
                     def supports_cat?
                       true
                     end
                     def supports_annotate?
                       respond_to?('annotate')
                     end
                     def root_url
                       @root_url
                     end
                     def url
                       @url
                     end
                     def path_encoding
                       nil
                     end
                     # get info about the svn repository
                     def info
                       return nil
                     end
                     # Returns the entry identified by path and revision identifier
                     # or nil if entry doesn't exist in the repository
                     def entry(path=nil, identifier=nil)
                       parts = path.to_s.split(%r{[\/\\]}).select {|n| !n.blank?}
                       search_path = parts[0..-2].join('/')
                       search_name = parts[-1]
                       if search_path.blank? && search_name.blank?
                         # Root entry
                         Entry.new(:path => '', :kind => 'dir')
                       else
                         # Search for the entry in the parent directory
                         es = entries(search_path, identifier)
                         es ? es.detect {|e| e.name == search_name} : nil
                       end
                     end
                     # Returns an Entries collection
                     # or nil if the given path doesn't exist in the repository
                     def entries(path=nil, identifier=nil, options={})
                       return nil
                     end
                     def branches
                       return nil
                     end
                     def tags
                       return nil
                     end
                     def default_branch
                       return nil
                     end
                     def properties(path, identifier=nil)
                       return nil
                     end
                     def revisions(path=nil, identifier_from=nil, identifier_to=nil, options={})
                       return nil
                     end
                     def diff(path, identifier_from, identifier_to=nil)
                       return nil
                     end
                     def cat(path, identifier=nil)
                       return nil
                     end
                     def with_leading_slash(path)
                       path ||= ''
                       (path[0,1]!="/") ? "/#{path}" : path
                     end
                     def with_trailling_slash(path)
                       path ||= ''
                       (path[-1,1] == "/") ? path : "#{path}/"
                     end
                     def without_leading_slash(path)
                       path ||= ''
                       path.gsub(%r{^/+}, '')
                     end
                     def without_trailling_slash(path)
                       path ||= ''
                       (path[-1,1] == "/") ? path[0..-2] : path
                      end
                     def shell_quote(str)
                       self.class.shell_quote(str)
                     end
                   private
                     def retrieve_root_url
                       info = self.info
                       info ? info.root_url : nil
                     end
                     def target(path, sq=true)
                       path ||= ''
                       base = path.match(/^\//) ? root_url : url
                       str = "#{base}/#{path}".gsub(/[?<>\*]/, '')
                       if sq
                         str = shell_quote(str)
                       end
                       str
                     end
                     def logger
                       self.class.logger
                     end
                     def shellout(cmd, options = {}, &block)
                       self.class.shellout(cmd, options, &block)
                     end
                     def self.logger
                       Rails.logger
                     end
                     def self.shellout(cmd, options = {}, &block)
                       if logger && logger.debug?
                         logger.debug "Shelling out: #{strip_credential(cmd)}"
                       end
                       if Rails.env == 'development'
                         # Capture stderr when running in dev environment
                         cmd = "#{cmd} 2>>#{shell_quote(Rails.root.join('log/scm.stderr.log').to_s)}"
                       end
                       begin
                         mode = "r+"
                         IO.popen(cmd, mode) do |io|
                           io.set_encoding("ASCII-8BIT") if io.respond_to?(:set_encoding)
                           io.close_write unless options[:write_stdin]
                           block.call(io) if block_given?
                         end
                       ## If scm command does not exist,
                       ## Linux JRuby 1.6.2 (ruby-1.8.7-p330) raises java.io.IOException
                       ## in production environment.
                       # rescue Errno::ENOENT => e
                       rescue Exception => e
                         msg = strip_credential(e.message)
                         # The command failed, log it and re-raise
                         logmsg = "SCM command failed, "
                         logmsg += "make sure that your SCM command (e.g. svn) is "
                         logmsg += "in PATH (#{ENV['PATH']})\n"
                         logmsg += "You can configure your scm commands in config/configuration.yml.\n"
                         logmsg += "#{strip_credential(cmd)}\n"
                         logmsg += "with: #{msg}"
                         logger.error(logmsg)
                         raise CommandFailed.new(msg)
                       end
                     end
                     # Hides username/password in a given command
                     def self.strip_credential(cmd)
                       q = (Redmine::Platform.mswin? ? '"' : "'")
                       cmd.to_s.gsub(/(\-\-(password|username))\s+(#{q}[^#{q}]+#{q}|[^#{q}]\S+)/, '\\1 xxxx')
                     end
                     def strip_credential(cmd)
                       self.class.strip_credential(cmd)
                     end
                     def scm_iconv(to, from, str)
                       return nil if str.nil?
                       return str if to == from
                       if str.respond_to?(:force_encoding)
                         str.force_encoding(from)
                         begin
                           str.encode(to)
                         rescue Exception => err
                           logger.error("failed to convert from #{from} to #{to}. #{err}")
                           nil
                         end
                       else
                         begin
                           Iconv.conv(to, from, str)
                         rescue Iconv::Failure => err
                           logger.error("failed to convert from #{from} to #{to}. #{err}")
                           nil
                         end
                       end
                     end
                     def parse_xml(xml)
                       if RUBY_PLATFORM == 'java'
                         xml = xml.sub(%r{<\?xml[^>]*\?>}, '')
                       end
                       ActiveSupport::XmlMini.parse(xml)
                     end
                   end
                   class Entries < Array
                     def sort_by_name
                       dup.sort! {|x,y|
                         if x.kind == y.kind
                           x.name.to_s <=> y.name.to_s
                         else
                           x.kind <=> y.kind
                         end
                       }
                     end
                     def revisions
                       revisions ||= Revisions.new(collect{|entry| entry.lastrev}.compact)
                     end
                   end
                   class Info
                     attr_accessor :root_url, :lastrev
                     def initialize(attributes={})
                       self.root_url = attributes[:root_url] if attributes[:root_url]
                       self.lastrev = attributes[:lastrev]
                     end
                   end
                   class Entry
                     attr_accessor :name, :path, :kind, :size, :lastrev, :changeset
                     def initialize(attributes={})
                       self.name = attributes[:name] if attributes[:name]
                       self.path = attributes[:path] if attributes[:path]
                       self.kind = attributes[:kind] if attributes[:kind]
                       self.size = attributes[:size].to_i if attributes[:size]
                       self.lastrev = attributes[:lastrev]
                     end
                     def is_file?
                       'file' == self.kind
                     end
                     def is_dir?
                       'dir' == self.kind
                     end
                     def is_text?
                       Redmine::MimeType.is_type?('text', name)
                     end
                     def author
                       if changeset
                         changeset.author.to_s
                       elsif lastrev
                         Redmine::CodesetUtil.replace_invalid_utf8(lastrev.author.to_s.split('<').first)
                       end
                     end
                   end
                   class Revisions < Array
                     def latest
                       sort {|x,y|
                         unless x.time.nil? or y.time.nil?
                           x.time <=> y.time
                         else
                         end
                       }.last
                     end
                   end
                   class Revision
                     attr_accessor :scmid, :name, :author, :time, :message,
                                   :paths, :revision, :branch, :identifier,
                                   :parents
                     def initialize(attributes={})
                       self.identifier = attributes[:identifier]
                       self.scmid      = attributes[:scmid]
                       self.name       = attributes[:name] || self.identifier
                       self.author     = attributes[:author]
                       self.time       = attributes[:time]
                       self.message    = attributes[:message] || ""
                       self.paths      = attributes[:paths]
                       self.revision   = attributes[:revision]
                       self.branch     = attributes[:branch]
                       self.parents    = attributes[:parents]
                     end
                     # Returns the readable identifier.
                     def format_identifier
                       self.identifier.to_s
                     end
                     def ==(other)
                       if other.nil?
                         false
                       elsif scmid.present?
                         scmid == other.scmid
                       elsif identifier.present?
                         identifier == other.identifier
                       elsif revision.present?
                         revision == other.revision
                       end
                     end
                   end
                   class Annotate
                     attr_reader :lines, :revisions
                     def initialize
                       @lines = []
                       @revisions = []
                     end
                     def add_line(line, revision)
                       @lines << line
                       @revisions << revision
                     end
                     def content
                       content = lines.join("\n")
                     end
                     def empty?
                       lines.empty?
                     end
                   end
                   class Branch < String
                     attr_accessor :revision, :scmid
                   end
                 end
               end
             end

test/unit/lib/redmine/export/pdf_test.rb 0 -1

             # Redmine - project management software
             # Copyright (C) 2006-2013  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../../../test_helper', __FILE__)
-            require 'iconv'
             class PdfTest < ActiveSupport::TestCase
               fixtures :users, :projects, :roles, :members, :member_roles,
                        :enabled_modules, :issues, :trackers, :attachments
               def test_fix_text_encoding_nil
                 assert_equal '', Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(nil, "UTF-8")
                 assert_equal '', Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(nil, "ISO-8859-1")
               end
               def test_rdm_pdf_iconv_cannot_convert_ja_cp932
                 encoding = ( RUBY_PLATFORM == 'java' ? "SJIS" : "CP932" )
                 utf8_txt_1  = "\xe7\x8b\x80\xe6\x85\x8b"
                 utf8_txt_2  = "\xe7\x8b\x80\xe6\x85\x8b\xe7\x8b\x80"
                 utf8_txt_3  = "\xe7\x8b\x80\xe7\x8b\x80\xe6\x85\x8b\xe7\x8b\x80"
                 if utf8_txt_1.respond_to?(:force_encoding)
                   txt_1 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_1, encoding)
                   txt_2 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_2, encoding)
                   txt_3 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_3, encoding)
                   assert_equal "?\x91\xd4", txt_1
                   assert_equal "?\x91\xd4?", txt_2
                   assert_equal "??\x91\xd4?", txt_3
                   assert_equal "ASCII-8BIT", txt_1.encoding.to_s
                   assert_equal "ASCII-8BIT", txt_2.encoding.to_s
                   assert_equal "ASCII-8BIT", txt_3.encoding.to_s
                 elsif RUBY_PLATFORM == 'java'
                   assert_equal "??",
                                Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_1, encoding)
                   assert_equal "???",
                                Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_2, encoding)
                   assert_equal "????",
                                Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_3, encoding)
                 else
                   assert_equal "???\x91\xd4",
                                Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_1, encoding)
                   assert_equal "???\x91\xd4???",
                                Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_2, encoding)
                   assert_equal "??????\x91\xd4???",
                                Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(utf8_txt_3, encoding)
                 end
               end
               def test_rdm_pdf_iconv_invalid_utf8_should_be_replaced_en
                 str1 = "Texte encod\xe9 en ISO-8859-1"
                 str2 = "\xe9a\xe9b\xe9c\xe9d\xe9e test"
                 str1.force_encoding("UTF-8") if str1.respond_to?(:force_encoding)
                 str2.force_encoding("ASCII-8BIT") if str2.respond_to?(:force_encoding)
                 txt_1 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str1, 'UTF-8')
                 txt_2 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str2, 'UTF-8')
                 if txt_1.respond_to?(:force_encoding)
                   assert_equal "ASCII-8BIT", txt_1.encoding.to_s
                   assert_equal "ASCII-8BIT", txt_2.encoding.to_s
                 end
                 assert_equal "Texte encod? en ISO-8859-1", txt_1
                 assert_equal "?a?b?c?d?e test", txt_2
               end
               def test_rdm_pdf_iconv_invalid_utf8_should_be_replaced_ja
                 str1 = "Texte encod\xe9 en ISO-8859-1"
                 str2 = "\xe9a\xe9b\xe9c\xe9d\xe9e test"
                 str1.force_encoding("UTF-8") if str1.respond_to?(:force_encoding)
                 str2.force_encoding("ASCII-8BIT") if str2.respond_to?(:force_encoding)
                 encoding = ( RUBY_PLATFORM == 'java' ? "SJIS" : "CP932" )
                 txt_1 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str1, encoding)
                 txt_2 = Redmine::Export::PDF::RDMPdfEncoding::rdm_from_utf8(str2, encoding)
                 if txt_1.respond_to?(:force_encoding)
                   assert_equal "ASCII-8BIT", txt_1.encoding.to_s
                   assert_equal "ASCII-8BIT", txt_2.encoding.to_s
                 end
                 assert_equal "Texte encod? en ISO-8859-1", txt_1
                 assert_equal "?a?b?c?d?e test", txt_2
               end
               def test_attach
                 set_fixtures_attachments_directory
                 str2 = "\x83e\x83X\x83g"
                 str2.force_encoding("ASCII-8BIT") if str2.respond_to?(:force_encoding)
                 encoding = ( RUBY_PLATFORM == 'java' ? "SJIS" : "CP932" )
                 a1 = Attachment.find(17)
                 a2 = Attachment.find(19)
                 User.current = User.find(1)
                 assert a1.readable?
                 assert a1.visible?
                 assert a2.readable?
                 assert a2.visible?
                 aa1 = Redmine::Export::PDF::RDMPdfEncoding::attach(Attachment.all, "Testfile.PNG", "UTF-8")
                 assert_not_nil aa1
                 assert_equal 17, aa1.id
                 aa2 = Redmine::Export::PDF::RDMPdfEncoding::attach(Attachment.all, "test#{str2}.png", encoding)
                 assert_not_nil aa2
                 assert_equal 19, aa2.id
                 User.current = nil
                 assert a1.readable?
                 assert (! a1.visible?)
                 assert a2.readable?
                 assert (! a2.visible?)
                 aa1 = Redmine::Export::PDF::RDMPdfEncoding::attach(Attachment.all, "Testfile.PNG", "UTF-8")
                 assert_equal nil, aa1
                 aa2 = Redmine::Export::PDF::RDMPdfEncoding::attach(Attachment.all, "test#{str2}.png", encoding)
                 assert_equal nil, aa2
                 set_tmp_attachments_directory
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages