roo 1.13.2 → 2.0.0beta1

data/lib/roo/excel2003xml.rb

@@ -1,300 +0,0 @@
-require 'date'
-require 'base64'
-require 'nokogiri'
-
-class Roo::Excel2003XML < Roo::Base
-
-  # initialization and opening of a spreadsheet file
-  # values for packed: :zip
-  def initialize(filename, options={}, deprecated_file_warning=:error)
-    if Hash === options
-      packed = options[:packed]
-      file_warning = options[:file_warning] || :error
-    else
-      warn 'Supplying `packed` or `file_warning` as separate arguments to `Roo::Excel2003XML.new` is deprecated. Use an options hash instead.'
-      packed = options
-      file_warning = deprecated_file_warning
-    end
-
-    make_tmpdir do |tmpdir|
-      filename = download_uri(filename, tmpdir) if uri?(filename)
-      filename = unzip(filename, tmpdir) if packed == :zip
-
-      file_type_check(filename,'.xml','an Excel 2003 XML', file_warning)
-      @filename = filename
-      unless File.file?(@filename)
-        raise IOError, "file #{@filename} does not exist"
-      end
-      @doc = load_xml(@filename)
-    end
-    super(filename, options)
-    @formula = Hash.new
-    @style = Hash.new
-    @style_defaults = Hash.new { |h,k| h[k] = [] }
-    @style_definitions = Hash.new
-    read_styles
-  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)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    if celltype(row,col,sheet) == :date
-      yyyy,mm,dd = @cell[sheet][[row,col]].split('-')
-      return Date.new(yyyy.to_i,mm.to_i,dd.to_i)
-    end
-    @cell[sheet][[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)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    @formula[sheet][[row,col]] && @formula[sheet][[row,col]]["oooc:".length..-1]
-  end
-  alias_method :formula?, :formula
-
-  class Font
-    attr_accessor :bold, :italic, :underline
-
-    def bold?
-      @bold == '1'
-    end
-
-    def italic?
-      @italic == '1'
-    end
-
-    def underline?
-      @underline != nil
-    end
-  end
-
-  # Given a cell, return the cell's style
-  def font(row, col, sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    style_name = @style[sheet][[row,col]] || @style_defaults[sheet][col - 1] || 'Default'
-    @style_definitions[style_name]
-  end
-
-  # returns the type of a cell:
-  # * :float
-  # * :string
-  # * :date
-  # * :percentage
-  # * :formula
-  # * :time
-  # * :datetime
-  def celltype(row,col,sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    if @formula[sheet][[row,col]]
-      return :formula
-    else
-      @cell_type[sheet][[row,col]]
-    end
-  end
-
-  def sheets
-    @doc.xpath("/ss:Workbook/ss:Worksheet").map do |sheet|
-      sheet['ss:Name']
-    end
-  end
-
-  # version of the openoffice document
-  # at 2007 this is always "1.0"
-  def officeversion
-    oo_version
-    @officeversion
-  end
-
-  # shows the internal representation of all cells
-  # mainly for debugging purposes
-  def to_s(sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    @cell[sheet].inspect
-  end
-
-  # save spreadsheet
-  def save #:nodoc:
-    42
-  end
-
-  # returns each formula in the selected sheet as an array of elements
-  # [row, col, formula]
-  def formulas(sheet=nil)
-    theformulas = Array.new
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    first_row(sheet).upto(last_row(sheet)) {|row|
-      first_column(sheet).upto(last_column(sheet)) {|col|
-        if formula?(row,col,sheet)
-          f = [row, col, formula(row,col,sheet)]
-          theformulas << f
-        end
-      }
-    }
-    theformulas
-  end
-
-  private
-
-  # read the version of the OO-Version
-  def oo_version
-    @doc.find("//*[local-name()='document-content']").each do |office|
-      @officeversion = office['version']
-    end
-  end
-
-  # helper function to set the internal representation of cells
-  def set_cell_values(sheet,x,y,i,v,value_type,formula,table_cell,str_v,style_name)
-    key = [y,x+i]
-    @cell_type[sheet] = {} unless @cell_type[sheet]
-    @cell_type[sheet][key] = value_type
-    @formula[sheet] = {} unless @formula[sheet]
-    @formula[sheet][key] = formula  if formula
-    @cell[sheet]    = {} unless @cell[sheet]
-    @style[sheet] = {} unless @style[sheet]
-    @style[sheet][key] = style_name
-    @cell[sheet][key] =
-      case @cell_type[sheet][key]
-      when :float
-        v.to_f
-      when :string
-        str_v
-      when :datetime
-        DateTime.parse(v)
-      when :percentage
-        v.to_f
-      # when :time
-      #   hms = v.split(':')
-      #   hms[0].to_i*3600 + hms[1].to_i*60 + hms[2].to_i
-      else
-        v
-      end
-  end
-
-  # read all cells in the selected sheet
-  #--
-  # the following construct means '4 blanks'
-  # some content <text:s text:c="3"/>
-  #++
-  def read_cells(sheet=nil)
-    sheet ||= @default_sheet
-    validate_sheet!(sheet)
-    return if @cells_read[sheet]
-    sheet_found = false
-    @doc.xpath("/ss:Workbook/ss:Worksheet[@ss:Name='#{sheet}']").each do |ws|
-      sheet_found = true
-      row = 1
-      col = 1
-      column_attributes = {}
-      idx = 0
-      ws.xpath('./ss:Table/ss:Column').each do |c|
-        column_attributes[(idx += 1).to_s] = c['StyleID']
-      end
-      ws.xpath('./ss:Table/ss:Row').each do |r|
-        skip_to_row = r['Index'].to_i
-        row = skip_to_row if skip_to_row > 0
-        style_name = r['StyleID'] if r['StyleID']
-        r.xpath('./ss:Cell').each do |c|
-          skip_to_col = c['Index'].to_i
-          col = skip_to_col if skip_to_col > 0
-          if c['StyleID']
-            style_name = c['StyleID']
-          elsif
-            style_name ||= column_attributes[c['Index']]
-          end
-          c.xpath('./ss:Data').each do |cell|
-            formula = cell['Formula']
-            value_type = cell['ss:Type'].downcase.to_sym
-            v =  cell.content
-            str_v = v
-            case value_type
-            when :number
-              v = v.to_f
-              value_type = :float
-            when :datetime
-              if v =~ /^1899-12-31T(\d{2}:\d{2}:\d{2})/
-                v = $1
-                value_type = :time
-              elsif v =~ /([^T]+)T00:00:00.000/
-                v = $1
-                value_type = :date
-              end
-            when :boolean
-              v = cell['boolean-value']
-            end
-            set_cell_values(sheet,col,row,0,v,value_type,formula,cell,str_v,style_name)
-          end
-          col += 1
-        end
-        row += 1
-        col = 1
-      end
-    end
-    if !sheet_found
-      raise RangeError, "Unable to find sheet #{sheet} for reading"
-    end
-    @cells_read[sheet] = true
-  end
-
-  def read_styles
-    @doc.xpath("/ss:Workbook/ss:Styles/ss:Style").each do |style|
-      style_id = style['ID']
-      @style_definitions[style_id] = Roo::Excel2003XML::Font.new
-      if font = style.at_xpath('./ss:Font')
-        @style_definitions[style_id].bold = font['Bold']
-        @style_definitions[style_id].italic = font['Italic']
-        @style_definitions[style_id].underline = font['Underline']
-      end
-    end
-  end
-
-  A_ROO_TYPE = {
-    "float"      => :float,
-    "string"     => :string,
-    "date"       => :date,
-    "percentage" => :percentage,
-    "time"       => :time,
-  }
-
-  def self.oo_type_2_roo_type(ootype)
-    return A_ROO_TYPE[ootype]
-  end
-
-  # helper method to convert compressed spaces and other elements within
-  # an text into a string
-  def children_to_string(children)
-    result = ''
-    children.each {|child|
-      if child.text?
-        result = result + child.content
-      else
-        if child.name == 's'
-          compressed_spaces = child['c'].to_i
-          # no explicit number means a count of 1:
-          if compressed_spaces == 0
-            compressed_spaces = 1
-          end
-          result = result + " "*compressed_spaces
-        else
-          result = result + child.content
-        end
-      end
-    }
-    result
-  end
-
-end # class

data/lib/roo/google.rb

@@ -1,292 +0,0 @@
-begin
-  require "google_drive"
-rescue LoadError => e
-  raise e, "Using Roo::Google requires the google_drive gem"
-end
-
-class Roo::Google < Roo::Base
-  attr_accessor :date_format, :datetime_format
-
-  # Creates a new Google Drive object.
-  def initialize(spreadsheet_key, options = {})
-    @filename = spreadsheet_key
-    @user = options[:user] || ENV['GOOGLE_MAIL']
-    @password = options[:password] || ENV['GOOGLE_PASSWORD']
-    @access_token = options[:access_token] || ENV['GOOGLE_TOKEN']
-
-    @worksheets = session.spreadsheet_by_key(@filename).worksheets
-    @sheets = @worksheets.map {|sheet| sheet.title }
-    super
-    @cell = Hash.new {|h,k| h[k]=Hash.new}
-    @cell_type = Hash.new {|h,k| h[k]=Hash.new}
-    @formula = Hash.new
-    @date_format = '%d/%m/%Y'
-    @datetime_format = '%d/%m/%Y %H:%M:%S'
-    @time_format = '%H:%M:%S'
-  end
-
-  # returns an array of sheet names in the spreadsheet
-  attr_reader :sheets
-
-  def date?(string)
-    Date.strptime(string, @date_format)
-    true
-  rescue
-    false
-  end
-
-  # is String a time with format HH:MM:SS?
-  def time?(string)
-    DateTime.strptime(string, @time_format)
-    true
-  rescue
-    false
-  end
-
-  def datetime?(string)
-    DateTime.strptime(string, @datetime_format)
-    true
-  rescue
-    false
-  end
-
-  def numeric?(string)
-    string =~ /^[0-9]+[\.]*[0-9]*$/
-  end
-
-  def timestring_to_seconds(value)
-    hms = value.split(':')
-    hms[0].to_i*3600 + hms[1].to_i*60 + hms[2].to_i
-  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)
-    sheet ||= @default_sheet
-    validate_sheet!(sheet) #TODO: 2007-12-16
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    value = @cell[sheet]["#{row},#{col}"]
-    if celltype(row,col,sheet) == :date
-      begin
-        return  Date.strptime(value, @date_format)
-      rescue ArgumentError
-        raise "Invalid Date #{sheet}[#{row},#{col}] #{value} using format '{@date_format}'"
-      end
-    elsif celltype(row,col,sheet) == :datetime
-      begin
-        return  DateTime.strptime(value, @datetime_format)
-      rescue ArgumentError
-        raise "Invalid DateTime #{sheet}[#{row},#{col}] #{value} using format '{@datetime_format}'"
-      end
-    end
-    return value
-  end
-
-  # returns the type of a cell:
-  # * :float
-  # * :string
-  # * :date
-  # * :percentage
-  # * :formula
-  # * :time
-  # * :datetime
-  def celltype(row, col, sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    if @formula.size > 0 && @formula[sheet]["#{row},#{col}"]
-      :formula
-    else
-      @cell_type[sheet]["#{row},#{col}"]
-    end
-  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)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    @formula[sheet]["#{row},#{col}"] && @formula[sheet]["#{row},#{col}"]
-  end
-  alias_method :formula?, :formula
-
-  # true, if the cell is empty
-  def empty?(row, col, sheet=nil)
-    value = cell(row, col, sheet)
-    return true unless value
-    return false if value.class == Date # a date is never empty
-    return false if value.class == Float
-    return false if celltype(row,col,sheet) == :time
-    value.empty?
-  end
-
-  # sets the cell to the content of 'value'
-  # a formula can be set in the form of '=SUM(...)'
-  def set(row,col,value,sheet=nil)
-    sheet ||= @default_sheet
-    validate_sheet!(sheet)
-
-    sheet_no = sheets.index(sheet)+1
-    row,col = normalize(row,col)
-    add_to_cell_roo(row,col,value,sheet_no)
-    # re-read the portion of the document that has changed
-    if @cells_read[sheet]
-      value, value_type = determine_datatype(value.to_s)
-
-      _set_value(row,col,value,sheet)
-      set_type(row,col,value_type,sheet)
-    end
-  end
-
-  # *DEPRECATED*: Use Roo::Google#set instead
-  def set_value(row,col,value,sheet=nil)
-    warn "[DEPRECATION] `set_value` is deprecated.  Please use `set` instead."
-    set(row,col,value,sheet)
-  end
-
-  # returns the first non-empty row in a sheet
-  def first_row(sheet=nil)
-    sheet ||= @default_sheet
-    unless @first_row[sheet]
-      sheet_no = sheets.index(sheet) + 1
-      @first_row[sheet], @last_row[sheet], @first_column[sheet], @last_column[sheet] =
-        oben_unten_links_rechts(sheet_no)
-    end
-    return @first_row[sheet]
-  end
-
-  # returns the last non-empty row in a sheet
-  def last_row(sheet=nil)
-    sheet ||= @default_sheet
-    unless @last_row[sheet]
-      sheet_no = sheets.index(sheet) + 1
-      @first_row[sheet], @last_row[sheet], @first_column[sheet], @last_column[sheet] =
-        oben_unten_links_rechts(sheet_no)
-    end
-    return @last_row[sheet]
-  end
-
-  # returns the first non-empty column in a sheet
-  def first_column(sheet=nil)
-    sheet ||= @default_sheet
-    unless @first_column[sheet]
-      sheet_no = sheets.index(sheet) + 1
-      @first_row[sheet], @last_row[sheet], @first_column[sheet], @last_column[sheet] =
-        oben_unten_links_rechts(sheet_no)
-    end
-    return @first_column[sheet]
-  end
-
-  # returns the last non-empty column in a sheet
-  def last_column(sheet=nil)
-    sheet ||= @default_sheet
-    unless @last_column[sheet]
-      sheet_no = sheets.index(sheet) + 1
-      @first_row[sheet], @last_row[sheet], @first_column[sheet], @last_column[sheet] =
-        oben_unten_links_rechts(sheet_no)
-    end
-    return @last_column[sheet]
-  end
-
-  private
-
-  def _set_value(row,col,value,sheet=nil)
-    sheet ||= @default_sheet
-    @cell[sheet][ "#{row},#{col}"] = value
-  end
-
-  def set_type(row,col,type,sheet=nil)
-    sheet ||= @default_sheet
-    @cell_type[sheet]["#{row},#{col}"] = type
-  end
-
-  # read all cells in a sheet.
-  def read_cells(sheet=nil)
-    sheet ||= @default_sheet
-    validate_sheet!(sheet)
-    return if @cells_read[sheet]
-
-    sheet_no = sheets.index(sheet)
-    ws = @worksheets[sheet_no]
-    for row in 1..ws.num_rows
-      for col in 1..ws.num_cols
-        key = "#{row},#{col}"
-        string_value = ws.input_value(row,col) # item['inputvalue'] ||  item['inputValue']
-        numeric_value = ws[row,col] #item['numericvalue']  ||  item['numericValue']
-        (value, value_type) = determine_datatype(string_value, numeric_value)
-        @cell[sheet][key] = value unless value == "" or value == nil
-        @cell_type[sheet][key] = value_type
-        @formula[sheet] = {} unless @formula[sheet]
-        @formula[sheet][key] = string_value if value_type == :formula
-      end
-    end
-    @cells_read[sheet] = true
-  end
-
-  def determine_datatype(val, numval=nil)
-    if val.nil? || val[0,1] == '='
-      ty = :formula
-      if numeric?(numval)
-        val = numval.to_f
-      else
-        val = numval
-      end
-    else
-      if datetime?(val)
-        ty = :datetime
-      elsif date?(val)
-        ty = :date
-      elsif numeric?(val)
-        ty = :float
-        val = val.to_f
-      elsif time?(val)
-        ty = :time
-        val = timestring_to_seconds(val)
-      else
-        ty = :string
-      end
-    end
-    return val, ty
-  end
-
-  def add_to_cell_roo(row,col,value, sheet_no=1)
-    sheet_no -= 1
-    @worksheets[sheet_no][row,col] = value
-    @worksheets[sheet_no].save
-  end
-  def entry_roo(value,row,col)
-    return value,row,col
-  end
-
-  def oben_unten_links_rechts(sheet_no)
-    ws = @worksheets[sheet_no-1]
-    rows = []
-    cols = []
-    for row in 1..ws.num_rows
-      for col in 1..ws.num_cols
-        rows << row if ws[row,col] and ws[row,col] != '' #TODO: besser?
-        cols << col if ws[row,col] and ws[row,col] != '' #TODO: besser?
-      end
-    end
-    return rows.min, rows.max, cols.min, cols.max
-  end
-
-  def reinitialize
-    initialize(@filename, user: @user, password: @password, access_token: @access_token)
-  end
-
-  def session
-    @session ||= if @user && @password
-                   GoogleDrive.login(@user, @password)
-                 elsif @access_token
-                   GoogleDrive.login_with_oauth(@access_token)
-                 else
-                   warn 'set user and password or access token'
-                 end
-  end
-end