culturecode-roo 2.0.1

data/lib/roo/csv.rb

@@ -0,0 +1,110 @@
+require 'csv'
+require 'time'
+
+# The CSV class can read csv files (must be separated with commas) which then
+# can be handled like spreadsheets. This means you can access cells like A5
+# within these files.
+# The CSV class provides only string objects. If you want conversions to other
+# types you have to do it yourself.
+#
+# You can pass options to the underlying CSV parse operation, via the
+# :csv_options option.
+#
+
+class Roo::CSV < Roo::Base
+
+  attr_reader :filename
+
+  # Returns an array with the names of the sheets. In CSV class there is only
+  # one dummy sheet, because a csv file cannot have more than one sheet.
+  def sheets
+    ['default']
+  end
+
+  def cell(row, col, sheet=nil)
+    sheet ||= default_sheet
+    read_cells(sheet)
+    @cell[normalize(row,col)]
+  end
+
+  def celltype(row, col, sheet=nil)
+    sheet ||= default_sheet
+    read_cells(sheet)
+    @cell_type[normalize(row,col)]
+  end
+
+  def cell_postprocessing(row,col,value)
+    value
+  end
+
+  def csv_options
+    @options[:csv_options] || {}
+  end
+
+  private
+
+  TYPE_MAP = {
+    String => :string,
+    Float => :float,
+    Date => :date,
+    DateTime => :datetime,
+  }
+
+  def celltype_class(value)
+    TYPE_MAP[value.class]
+  end
+
+  def each_row(options, &block)
+    if uri?(filename)
+      make_tmpdir do |tmpdir|
+        tmp_filename = download_uri(filename, tmpdir)
+        CSV.foreach(tmp_filename, options, &block)
+      end
+    else
+      CSV.foreach(filename, options, &block)
+    end
+  end
+
+  def read_cells(sheet = default_sheet)
+    sheet ||= default_sheet
+    return if @cells_read[sheet]
+    @first_row[sheet] = 1
+    @last_row[sheet] = 0
+    @first_column[sheet] = 1
+    @last_column[sheet] = 1
+    rownum = 1
+    each_row csv_options do |row|
+      row.each_with_index do |elem,i|
+        @cell[[rownum,i+1]] = cell_postprocessing rownum,i+1, elem
+        @cell_type[[rownum,i+1]] = celltype_class @cell[[rownum,i+1]]
+        if i+1 > @last_column[sheet]
+          @last_column[sheet] += 1
+        end
+      end
+      rownum += 1
+      @last_row[sheet] += 1
+    end
+    @cells_read[sheet] = true
+    #-- adjust @first_row if neccessary
+    while !row(@first_row[sheet]).any? and @first_row[sheet] < @last_row[sheet]
+      @first_row[sheet] += 1
+    end
+    #-- adjust @last_row if neccessary
+    while !row(@last_row[sheet]).any? and @last_row[sheet] and
+        @last_row[sheet] > @first_row[sheet]
+      @last_row[sheet] -= 1
+    end
+    #-- adjust @first_column if neccessary
+    while !column(@first_column[sheet]).any? and
+          @first_column[sheet] and
+          @first_column[sheet] < @last_column[sheet]
+      @first_column[sheet] += 1
+    end
+    #-- adjust @last_column if neccessary
+    while !column(@last_column[sheet]).any? and
+          @last_column[sheet] and
+          @last_column[sheet] > @first_column[sheet]
+      @last_column[sheet] -= 1
+    end
+  end
+end

data/lib/roo/excelx.rb

@@ -0,0 +1,542 @@
+require 'date'
+require 'nokogiri'
+require 'roo/link'
+require 'roo/utils'
+require 'zip/filesystem'
+
+class Roo::Excelx < Roo::Base
+  autoload :Workbook, 'roo/excelx/workbook'
+  autoload :SharedStrings, 'roo/excelx/shared_strings'
+  autoload :Styles, 'roo/excelx/styles'
+
+  autoload :Relationships, 'roo/excelx/relationships'
+  autoload :Comments, 'roo/excelx/comments'
+  autoload :SheetDoc, 'roo/excelx/sheet_doc'
+
+  module Format
+    EXCEPTIONAL_FORMATS = {
+      'h:mm am/pm' => :date,
+      'h:mm:ss am/pm' => :date,
+    }
+
+    STANDARD_FORMATS = {
+      0 => 'General',
+      1 => '0',
+      2 => '0.00',
+      3 => '#,##0',
+      4 => '#,##0.00',
+      9 => '0%',
+      10 => '0.00%',
+      11 => '0.00E+00',
+      12 => '# ?/?',
+      13 => '# ??/??',
+      14 => 'mm-dd-yy',
+      15 => 'd-mmm-yy',
+      16 => 'd-mmm',
+      17 => 'mmm-yy',
+      18 => 'h:mm AM/PM',
+      19 => 'h:mm:ss AM/PM',
+      20 => 'h:mm',
+      21 => 'h:mm:ss',
+      22 => 'm/d/yy h:mm',
+      37 => '#,##0 ;(#,##0)',
+      38 => '#,##0 ;[Red](#,##0)',
+      39 => '#,##0.00;(#,##0.00)',
+      40 => '#,##0.00;[Red](#,##0.00)',
+      45 => 'mm:ss',
+      46 => '[h]:mm:ss',
+      47 => 'mmss.0',
+      48 => '##0.0E+0',
+      49 => '@',
+    }
+
+    def to_type(format)
+      format = format.to_s.downcase
+      if format == 'general'
+        :string
+      elsif type = EXCEPTIONAL_FORMATS[format]
+        type
+      elsif format.include?('#')
+        :float
+      elsif !format.match(/d+(?![\]])/).nil? || format.include?('y')
+        if format.include?('h') || format.include?('s')
+          :datetime
+        else
+          :date
+        end
+      elsif format.include?('h') || format.include?('s')
+        :time
+      elsif format.include?('%')
+        :percentage
+      else
+        :float
+      end
+    end
+
+    module_function :to_type
+  end
+
+  class Cell
+    attr_reader :type, :formula, :value, :excelx_type, :excelx_value, :style, :hyperlink, :coordinate
+
+    def initialize(value, type, formula, excelx_type, excelx_value, style, hyperlink, base_date, coordinate)
+      @type = type
+      @formula = formula
+      @base_date = base_date if [:date, :datetime].include?(@type)
+      @excelx_type = excelx_type
+      @excelx_value = excelx_value
+      @style = style
+      @value = type_cast_value(value)
+      @value = Roo::Link.new(hyperlink, @value.to_s) if hyperlink
+      @coordinate = coordinate
+    end
+
+    def type
+      if @formula
+        :formula
+      elsif @value.is_a?(Roo::Link)
+        :link
+      else
+        @type
+      end
+    end
+
+    class Coordinate
+      attr_accessor :row, :column
+
+      def initialize(row, column)
+        @row, @column = row, column
+      end
+    end
+
+    private
+
+    def type_cast_value(value)
+      case @type
+      when :float, :percentage
+        value.to_f
+      when :date
+        yyyy,mm,dd = (@base_date+value.to_i).strftime("%Y-%m-%d").split('-')
+        Date.new(yyyy.to_i,mm.to_i,dd.to_i)
+      when :datetime
+        create_datetime_from((@base_date+value.to_f.round(6)).strftime("%Y-%m-%d %H:%M:%S.%N"))
+      when :time
+        value.to_f*(24*60*60)
+      when :string
+        value
+      else
+        value
+      end
+    end
+
+    def create_datetime_from(datetime_string)
+      date_part,time_part = round_time_from(datetime_string).split(' ')
+      yyyy,mm,dd = date_part.split('-')
+      hh,mi,ss = time_part.split(':')
+      DateTime.civil(yyyy.to_i,mm.to_i,dd.to_i,hh.to_i,mi.to_i,ss.to_i)
+    end
+
+    def round_time_from(datetime_string)
+      date_part,time_part = datetime_string.split(' ')
+      yyyy,mm,dd = date_part.split('-')
+      hh,mi,ss = time_part.split(':')
+      Time.new(yyyy.to_i, mm.to_i, dd.to_i, hh.to_i, mi.to_i, ss.to_r).round(0).strftime("%Y-%m-%d %H:%M:%S")
+    end
+  end
+
+  class Sheet
+    def initialize(name, rels_path, sheet_path, comments_path, styles, shared_strings, workbook)
+      @name = name
+      @rels = Relationships.new(rels_path)
+      @comments = Comments.new(comments_path)
+      @styles = styles
+      @sheet = SheetDoc.new(sheet_path, @rels, @styles, shared_strings, workbook)
+    end
+
+    def cells
+      @cells ||= @sheet.cells(@rels)
+    end
+
+    def present_cells
+      @present_cells ||= cells.select {|key, cell| cell && cell.value }
+    end
+
+    # Yield each row as array of Excelx::Cell objects
+    # accepts options max_rows (int) (offset by 1 for header)
+    # and pad_cells (boolean)
+    def each_row(options = {}, &block)
+      row_count = 0
+      @sheet.each_row_streaming do |row|
+        break if options[:max_rows] && row_count == options[:max_rows] + 1
+        block.call(cells_for_row_element(row, options)) if block_given?
+        row_count += 1
+      end
+    end
+
+    def row(row_number)
+      first_column.upto(last_column).map do |col|
+        cells[[row_number,col]]
+      end.map {|cell| cell && cell.value }
+    end
+
+    def column(col_number)
+      first_row.upto(last_row).map do |row|
+        cells[[row,col_number]]
+      end.map {|cell| cell && cell.value }
+    end
+
+    # returns the number of the first non-empty row
+    def first_row
+      @first_row ||= present_cells.keys.map {|row, col| row }.min
+    end
+
+    def last_row
+      @last_row ||= present_cells.keys.map {|row, col| row }.max
+    end
+
+    # returns the number of the first non-empty column
+    def first_column(sheet=nil)
+      @first_column ||= present_cells.keys.map {|row, col| col }.min
+    end
+
+    # returns the number of the last non-empty column
+    def last_column(sheet=nil)
+      @last_column ||= present_cells.keys.map {|row, col| col }.max
+    end
+
+    def excelx_format(key)
+      @styles.style_format(cells[key].style).to_s
+    end
+
+    def hyperlinks
+      @hyperlinks ||= @sheet.hyperlinks(@rels)
+    end
+
+    def comments
+      @comments.comments
+    end
+
+    def dimensions
+      @sheet.dimensions
+    end
+
+    private
+
+    # Take an xml row and return an array of Excelx::Cell objects
+    # optionally pad array to header width(assumed 1st row).
+    # takes option pad_cells (boolean) defaults false
+    def cells_for_row_element(row_element, options = {})
+      return [] unless row_element
+      cell_col = 0
+      cells = []
+      @sheet.each_cell(row_element) do |cell|
+        cells.concat(pad_cells(cell, cell_col)) if options[:pad_cells]
+        cells << cell
+        cell_col = cell.coordinate.column
+      end
+      cells
+    end
+
+    def pad_cells(cell, last_column)
+      pad = []
+      (cell.coordinate.column - 1 - last_column).times { pad << nil }
+      pad
+    end
+  end
+
+  ExceedsMaxError = Class.new(StandardError)
+
+  # initialization and opening of a spreadsheet file
+  # values for packed: :zip
+  # optional cell_max (int) parameter for early aborting attempts to parse
+  # enormous documents.
+  def initialize(filename, options = {})
+    packed = options[:packed]
+    file_warning = options.fetch(:file_warning, :error)
+    cell_max = options.delete(:cell_max)
+
+    file_type_check(filename,'.xlsx','an Excel-xlsx', file_warning, packed)
+
+    @tmpdir = make_tmpdir(filename.split('/').last, options[:tmpdir_root])
+    @filename = local_filename(filename, @tmpdir, packed)
+    @comments_files = []
+    @rels_files = []
+    process_zipfile(@tmpdir, @filename)
+
+    @sheet_names = workbook.sheets.map { |sheet| sheet['name'] }
+    @sheets = []
+    @sheets_by_name = Hash[@sheet_names.map.with_index do |sheet_name, n|
+      @sheets[n] = Sheet.new(sheet_name, @rels_files[n], @sheet_files[n], @comments_files[n], styles, shared_strings, workbook)
+      [sheet_name, @sheets[n]]
+    end]
+
+    if cell_max
+      cell_count = ::Roo::Utils.num_cells_in_range(sheet_for(options.delete(:sheet)).dimensions)
+      raise ExceedsMaxError.new("Excel file exceeds cell maximum: #{cell_count} > #{cell_max}") if cell_count > cell_max
+    end
+
+    super
+  end
+
+  def method_missing(method,*args)
+    if label = workbook.defined_names[method.to_s]
+      sheet_for(label.sheet).cells[label.key].value
+    else
+      # call super for methods like #a1
+      super
+    end
+  end
+
+  def sheets
+    @sheet_names
+  end
+
+  def sheet_for(sheet)
+    sheet ||= default_sheet
+    validate_sheet!(sheet)
+    @sheets_by_name[sheet]
+  end
+
+  # Returns the content of a spreadsheet-cell.
+  # (1,1) is the upper left corner.
+  # (1,1), (1,'A'), ('A',1), ('a',1) all refers to the
+  # cell at the first line and first row.
+  def cell(row, col, sheet=nil)
+    key = normalize(row,col)
+    cell = sheet_for(sheet).cells[key]
+    cell.value if cell
+  end
+
+  def row(rownumber,sheet=nil)
+    sheet_for(sheet).row(rownumber)
+  end
+
+  # returns all values in this column as an array
+  # column numbers are 1,2,3,... like in the spreadsheet
+  def column(column_number,sheet=nil)
+    if column_number.is_a?(::String)
+      column_number = ::Roo::Utils.letter_to_number(column_number)
+    end
+    sheet_for(sheet).column(column_number)
+  end
+
+  # returns the number of the first non-empty row
+  def first_row(sheet=nil)
+    sheet_for(sheet).first_row
+  end
+
+  # returns the number of the last non-empty row
+  def last_row(sheet=nil)
+    sheet_for(sheet).last_row
+  end
+
+  # returns the number of the first non-empty column
+  def first_column(sheet=nil)
+    sheet_for(sheet).first_column
+  end
+
+  # returns the number of the last non-empty column
+  def last_column(sheet=nil)
+    sheet_for(sheet).last_column
+  end
+
+  # set a cell to a certain value
+  # (this will not be saved back to the spreadsheet file!)
+  def set(row,col,value, sheet = nil) #:nodoc:
+    key = normalize(row,col)
+    cell_type = cell_type_by_value(value)
+    sheet_for(sheet).cells[key] = Cell.new(value, cell_type, nil, cell_type, value, nil, nil, nil, Cell::Coordinate.new(row, col))
+  end
+
+
+  # Returns the formula at (row,col).
+  # Returns nil if there is no formula.
+  # The method #formula? checks if there is a formula.
+  def formula(row,col,sheet=nil)
+    key = normalize(row,col)
+    sheet_for(sheet).cells[key].formula
+  end
+
+  # Predicate methods really should return a boolean
+  # value. Hopefully no one was relying on the fact that this
+  # previously returned either nil/formula
+  def formula?(*args)
+    !!formula(*args)
+  end
+
+  # returns each formula in the selected sheet as an array of tuples in following format
+  # [[row, col, formula], [row, col, formula],...]
+  def formulas(sheet=nil)
+    sheet_for(sheet).cells.select {|_, cell| cell.formula }.map do |(x, y), cell|
+      [x, y, cell.formula]
+    end
+  end
+
+  # Given a cell, return the cell's style
+  def font(row, col, sheet=nil)
+    key = normalize(row,col)
+    styles.definitions[sheet_for(sheet).cells[key].style]
+  end
+
+  # returns the type of a cell:
+  # * :float
+  # * :string,
+  # * :date
+  # * :percentage
+  # * :formula
+  # * :time
+  # * :datetime
+  def celltype(row,col,sheet=nil)
+    key = normalize(row, col)
+    sheet_for(sheet).cells[key].type
+  end
+
+  # returns the internal type of an excel cell
+  # * :numeric_or_formula
+  # * :string
+  # Note: this is only available within the Excelx class
+  def excelx_type(row,col,sheet=nil)
+    key = normalize(row,col)
+    sheet_for(sheet).cells[key].excelx_type
+  end
+
+  # returns the internal value of an excelx cell
+  # Note: this is only available within the Excelx class
+  def excelx_value(row,col,sheet=nil)
+    key = normalize(row,col)
+    sheet_for(sheet).cells[key].excelx_value
+  end
+
+  # returns the internal format of an excel cell
+  def excelx_format(row,col,sheet=nil)
+    key = normalize(row,col)
+    sheet_for(sheet).excelx_format(key)
+  end
+
+  def empty?(row,col,sheet=nil)
+    sheet = sheet_for(sheet)
+    key = normalize(row,col)
+    cell = sheet.cells[key]
+    !cell || !cell.value || (cell.type == :string && cell.value.empty?) \
+      || (row < sheet.first_row || row > sheet.last_row || col < sheet.first_column || col > sheet.last_column)
+  end
+
+  # shows the internal representation of all cells
+  # for debugging purposes
+  def to_s(sheet=nil)
+    sheet_for(sheet).cells.inspect
+  end
+
+  # returns the row,col values of the labelled cell
+  # (nil,nil) if label is not defined
+  def label(name)
+    labels = workbook.defined_names
+    if labels.empty? || !labels.key?(name)
+      [nil,nil,nil]
+    else
+      [labels[name].row,
+        labels[name].col,
+        labels[name].sheet]
+    end
+  end
+
+  # Returns an array which all labels. Each element is an array with
+  # [labelname, [row,col,sheetname]]
+  def labels
+    @labels ||= workbook.defined_names.map do |name, label|
+      [ name,
+        [ label.row,
+          label.col,
+          label.sheet,
+        ] ]
+    end
+  end
+
+  def hyperlink?(row,col,sheet=nil)
+    !!hyperlink(row, col, sheet)
+  end
+
+  # returns the hyperlink at (row/col)
+  # nil if there is no hyperlink
+  def hyperlink(row,col,sheet=nil)
+    key = normalize(row,col)
+    sheet_for(sheet).hyperlinks[key]
+  end
+
+  # returns the comment at (row/col)
+  # nil if there is no comment
+  def comment(row,col,sheet=nil)
+    key = normalize(row,col)
+    sheet_for(sheet).comments[key]
+  end
+
+  # true, if there is a comment
+  def comment?(row,col,sheet=nil)
+    !!comment(row,col,sheet)
+  end
+
+  def comments(sheet=nil)
+    sheet_for(sheet).comments.map do |(x, y), comment|
+      [x, y, comment]
+    end
+  end
+
+  # Yield an array of Excelx::Cell
+  # Takes options for sheet, pad_cells, and max_rows
+  def each_row_streaming(options={})
+    sheet_for(options.delete(:sheet)).each_row(options) { |row| yield row }
+  end
+
+  private
+
+  # Extracts all needed files from the zip file
+  def process_zipfile(tmpdir, zipfilename)
+    @sheet_files = []
+    Zip::File.foreach(zipfilename) do |entry|
+      path =
+        case entry.name.downcase
+        when /workbook.xml$/
+          "#{tmpdir}/roo_workbook.xml"
+        when /sharedstrings.xml$/
+          "#{tmpdir}/roo_sharedStrings.xml"
+        when /styles.xml$/
+          "#{tmpdir}/roo_styles.xml"
+        when /sheet.xml$/
+          path = "#{tmpdir}/roo_sheet"
+          @sheet_files.unshift(path)
+          path
+        when /sheet([0-9]+).xml$/
+          # Numbers 3.1 exports first sheet without sheet number. Such sheets
+          # are always added to the beginning of the array which, naturally,
+          # causes other sheets to be pushed to the next index which could
+          # lead to sheet references getting overwritten, so we need to
+          # handle that case specifically.
+          nr = $1
+          sheet_files_index = nr.to_i - 1
+          sheet_files_index += 1 if @sheet_files[sheet_files_index]
+          @sheet_files[sheet_files_index] = "#{tmpdir}/roo_sheet#{nr.to_i}"
+        when /comments([0-9]+).xml$/
+          nr = $1
+          @comments_files[nr.to_i-1] = "#{tmpdir}/roo_comments#{nr}"
+        when /sheet([0-9]+).xml.rels$/
+          nr = $1
+          @rels_files[nr.to_i-1] = "#{tmpdir}/roo_rels#{nr}"
+        end
+      if path
+        entry.extract(path)
+      end
+    end
+  end
+
+  def styles
+    @styles ||= Styles.new(File.join(@tmpdir, 'roo_styles.xml'))
+  end
+
+  def shared_strings
+    @shared_strings ||= SharedStrings.new(File.join(@tmpdir, 'roo_sharedStrings.xml'))
+  end
+
+  def workbook
+    @workbook ||= Workbook.new(File.join(@tmpdir, "roo_workbook.xml"))
+  end
+end