roo 1.13.2 → 2.0.0beta1

data/Gemfile.lock

@@ -1,78 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    addressable (2.3.5)
-    crack (0.4.1)
-      safe_yaml (~> 0.9.0)
-    diff-lcs (1.2.1)
-    faraday (0.8.7)
-      multipart-post (~> 1.1)
-    git (1.2.5)
-    google_drive (0.3.6)
-      nokogiri (>= 1.4.4, != 1.5.2, != 1.5.1)
-      oauth (>= 0.3.6)
-      oauth2 (>= 0.5.0)
-    httpauth (0.2.0)
-    jeweler (1.8.3)
-      bundler (~> 1.0)
-      git (>= 1.2.5)
-      rake
-      rdoc
-    json (1.7.7)
-    json (1.7.7-java)
-    jwt (0.1.8)
-      multi_json (>= 1.5)
-    multi_json (1.7.3)
-    multi_xml (0.5.3)
-    multipart-post (1.2.0)
-    nokogiri (1.5.6)
-    nokogiri (1.5.6-java)
-    oauth (0.4.7)
-    oauth2 (0.9.1)
-      faraday (~> 0.8)
-      httpauth (~> 0.1)
-      jwt (~> 0.1.4)
-      multi_json (~> 1.0)
-      multi_xml (~> 0.5)
-      rack (~> 1.2)
-    rack (1.5.2)
-    rake (0.9.2.2)
-    rdoc (3.12.2)
-      json (~> 1.4)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.0)
-    ruby-ole (1.2.11.6)
-    rubyzip (1.0.0)
-    safe_yaml (0.9.4)
-    shoulda (3.0.1)
-      shoulda-context (~> 1.0.0)
-      shoulda-matchers (~> 1.0.0)
-    shoulda-context (1.0.0)
-    shoulda-matchers (1.0.0)
-    spreadsheet (0.8.2)
-      ruby-ole (>= 1.0)
-    vcr (2.5.0)
-    webmock (1.13.0)
-      addressable (>= 2.2.7)
-      crack (>= 0.3.2)
-
-PLATFORMS
-  java
-  ruby
-
-DEPENDENCIES
-  google_drive
-  jeweler
-  nokogiri
-  rspec
-  rubyzip
-  shoulda
-  spreadsheet (> 0.6.4)
-  vcr
-  webmock

data/README.markdown

@@ -1,126 +0,0 @@
-# README for Roo
-
-Roo implements read access for all spreadsheet types and read/write access for
-Google spreadsheets. It can handle
-* OpenOffice
-* Excel
-* Google spreadsheets
-* Excelx
-* LibreOffice
-* CSV
-
-## Notes
-
-### XLS
-
-There is no support for formulas in Roo for .xls files - you can get the result
-of a formula but not the formula itself.
-
-### Google Spreadsheet
-
-Using Roo to access Google spreadsheets requires you install the 'google-spreadsheet-ruby' gem separately.
-
-## License
-
-While Roo is licensed under the MIT / Expat license, please note that the 'spreadsheet' gem [is released under](https://github.com/zdavatz/spreadsheet/blob/master/LICENSE.txt) the GPLv3 license.
-
-## Usage:
-
-```ruby
-require 'roo'
-
-s = Roo::OpenOffice.new("myspreadsheet.ods")      # loads an OpenOffice Spreadsheet
-s = Roo::Excel.new("myspreadsheet.xls")           # loads an Excel Spreadsheet
-s = Roo::Google.new("myspreadsheetkey_at_google") # loads a Google Spreadsheet
-s = Roo::Excelx.new("myspreadsheet.xlsx")         # loads an Excel Spreadsheet for Excel .xlsx files
-s = Roo::CSV.new("mycsv.csv")                     # loads a CSV file
-
-# You can use CSV to load TSV files, or files of a certain encoding by passing
-# in options under the :csv_options key
-s = Roo::CSV.new("mytsv.tsv", csv_options: {col_sep: "\t"}) # TSV
-s = Roo::CSV.new("mycsv.csv", csv_options: {encoding: Encoding::ISO_8859_1}) # csv with explicit encoding
-
-s.default_sheet = s.sheets.first             # first sheet in the spreadsheet file will be used
-
-# s.sheets is an array which holds the names of the sheets within
-# a spreadsheet.
-# you can also write
-# s.default_sheet = s.sheets[3] or
-# s.default_sheet = 'Sheet 3'
-
-s.cell(1,1)                                 # returns the content of the first row/first cell in the sheet
-s.cell('A',1)                               # same cell
-s.cell(1,'A')                               # same cell
-s.cell(1,'A',s.sheets[0])                   # same cell
-
-# almost all methods have an optional argument 'sheet'.
-# If this parameter is omitted, the default_sheet will be used.
-
-s.info                                      # prints infos about the spreadsheet file
-
-s.first_row                                 # the number of the first row
-s.last_row                                  # the number of the last row
-s.first_column                              # the number of the first column
-s.last_column                               # the number of the last column
-
-# limited font information is available
-
-s.font(1,1).bold?
-s.font(1,1).italic?
-s.font(1,1).underline?
-
-
-# Spreadsheet.open can accept both files and paths
-
-xls = Roo::Spreadsheet.open('./new_prices.xls')
-
-# If the File.path or provided path string does not have an extension, you can optionally
-# provide one as a string or symbol
-
-xls = Roo::Spreadsheet.open('./rails_temp_upload', extension: :xls)
-
-# no more setting xls.default_sheet, just use this
-
-xls.sheet('Info').row(1)
-xls.sheet(0).row(1)
-
-# excel likes to create random "Data01" sheets for macros
-# use this to find the sheet with the most data to parse
-
-xls.longest_sheet
-
-# this excel file has multiple worksheets, let's iterate through each of them and process
-
-xls.each_with_pagename do |name, sheet|
-  p sheet.row(1)
-end
-
-# pull out a hash of exclusive column data (get rid of useless columns and save memory)
-
-xls.each(:id => 'UPC',:qty => 'ATS') {|hash| arr << hash}
-#=> hash will appear like {:upc=>727880013358, :qty => 12}
-
-# NOTE: .parse does the same as .each, except it returns an array (similar to each vs. map)
-
-# not sure exactly what a column will be named? try a wildcard search with the character *
-# regex characters are allowed ('^price\s')
-# case insensitive
-
-xls.parse(:id => 'UPC*SKU',:qty => 'ATS*\sATP\s*QTY$')
-
-# if you need to locate the header row and assign the header names themselves,
-# use the :header_search option
-
-xls.parse(:header_search => ['UPC*SKU','ATS*\sATP\s*QTY$'])
-#=> each element will appear in this fashion:
-#=> {"UPC" => 123456789012, "STYLE" => "987B0", "COLOR" => "blue", "QTY" => 78}
-
-# want to strip out annoying unicode characters and surrounding white space?
-
-xls.parse(:clean => true)
-
-# another bonus feature is a patch to prevent the Spreadsheet gem from parsing
-# thousands and thousands of blank lines. i got fed up after watching my computer
-# nearly catch fire for 4 hours for a spreadsheet with only 200 ACTUAL lines
-# - located in lib/roo/worksheet.rb
-```

data/VERSION

@@ -1 +0,0 @@
-1.13.2

data/lib/roo/excel.rb

@@ -1,355 +0,0 @@
-require 'spreadsheet'
-
-# Class for handling Excel-Spreadsheets
-class Roo::Excel < Roo::Base
-  FORMULAS_MESSAGE = 'the spreadsheet gem does not support forumulas, so roo can not.'
-  CHARGUESS =
-    begin
-      require 'charguess'
-      true
-    rescue LoadError
-      false
-    end
-
-  attr_reader :workbook
-
-  # Creates a new Excel spreadsheet object.
-  # Parameter packed: :zip - File is a zip-file
-  def initialize(filename, options = {}, deprecated_file_warning = :error)
-    if Hash === options
-      packed = options[:packed]
-      file_warning = options[:file_warning] || :error
-      mode = options[:mode] || "rb+"
-    else
-      warn 'Supplying `packed` or `file_warning` as separate arguments to `Roo::Excel.new` is deprecated. Use an options hash instead.'
-      packed = options
-      mode = "rb+"
-      file_warning = deprecated_file_warning
-    end
-
-    file_type_check(filename,'.xls','an Excel', file_warning, packed)
-    make_tmpdir do |tmpdir|
-      filename = download_uri(filename, tmpdir) if uri?(filename)
-      filename = open_from_stream(filename[7..-1], tmpdir) if filename[0,7] == "stream:"
-      filename = unzip(filename, tmpdir) if packed == :zip
-
-      @filename = filename
-      unless File.file?(@filename)
-        raise IOError, "file #{@filename} does not exist"
-      end
-      @workbook = Spreadsheet.open(filename, mode)
-    end
-    super(filename, options)
-    @formula = Hash.new
-    @fonts = Hash.new
-  end
-
-  def encoding=(codepage)
-    @workbook.encoding = codepage
-  end
-
-  # returns an array of sheet names in the spreadsheet
-  def sheets
-    @workbook.worksheets.collect {|worksheet| normalize_string(worksheet.name)}
-  end
-
-  # this method lets you find the worksheet with the most data
-  def longest_sheet
-    sheet(@workbook.worksheets.inject {|m,o|
-      o.row_count > m.row_count ? o : m
-    }.name)
-  end
-
-  # returns the content of a cell. The upper left corner is (1,1) or ('A',1)
-  def cell(row,col,sheet=nil)
-    sheet ||= @default_sheet
-    validate_sheet!(sheet)
-
-    read_cells(sheet)
-    raise "should be read" unless @cells_read[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
-    if celltype(row,col,sheet) == :string
-      return platform_specific_encoding(@cell[sheet][[row,col]])
-    else
-      if @cell[sheet] and @cell[sheet][[row,col]]
-        return @cell[sheet][[row,col]]
-      else
-        return nil
-      end
-    end
-  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)
-    begin
-      if @formula[sheet] and @formula[sheet][[row,col]]
-        :formula
-      elsif @cell_type[sheet]
-        @cell_type[sheet][[row,col]]
-      end
-    rescue
-      puts "Error in sheet #{sheet}, row #{row}, col #{col}"
-      raise
-    end
-  end
-
-  # returns NO formula in excel spreadsheets
-  def formula(row,col,sheet=nil)
-    raise NotImplementedError, FORMULAS_MESSAGE
-  end
-  alias_method :formula?, :formula
-
-  # returns NO formulas in excel spreadsheets
-  def formulas(sheet=nil)
-    raise NotImplementedError, FORMULAS_MESSAGE
-  end
-
-  # Given a cell, return the cell's font
-  def font(row, col, sheet=nil)
-    sheet ||= @default_sheet
-    read_cells(sheet)
-    row,col = normalize(row,col)
-    @fonts[sheet][[row,col]]
-  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
-
-  private
-
-  # converts name of a sheet to index (0,1,2,..)
-  def sheet_no(name)
-    return name-1 if name.kind_of?(Fixnum)
-    i = 0
-    @workbook.worksheets.each do |worksheet|
-      return i if name == normalize_string(worksheet.name)
-      i += 1
-    end
-    raise StandardError, "sheet '#{name}' not found"
-  end
-
-  def normalize_string(value)
-    value = every_second_null?(value) ? remove_every_second_null(value) : value
-    if CHARGUESS && encoding = CharGuess::guess(value)
-      encoding.encode Encoding::UTF_8
-    else
-      platform_specific_encoding(value)
-    end
-  end
-
-  def platform_specific_encoding(value)
-    result =
-      case RUBY_PLATFORM.downcase
-      when /darwin|solaris/
-        value.encode Encoding::UTF_8
-      when /mswin32/
-        value.encode Encoding::ISO_8859_1
-      else
-        value
-      end
-    if every_second_null?(result)
-      result = remove_every_second_null(result)
-    end
-    result
-  end
-
-  def every_second_null?(str)
-    result = true
-    return false if str.length < 2
-    0.upto(str.length/2-1) do |i|
-      if str[i*2+1,1] != "\000"
-        result = false
-        break
-      end
-    end
-    result
-  end
-
-  def remove_every_second_null(str)
-    result = ''
-    0.upto(str.length/2-1) do |i|
-      c = str[i*2,1]
-      result += c
-    end
-    result
-  end
-
-  # helper function to set the internal representation of cells
-  def set_cell_values(sheet,row,col,i,v,value_type,formula,tr,font)
-    #key = "#{y},#{x+i}"
-    key = [row,col+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]
-    @fonts[sheet] = {} unless @fonts[sheet]
-    @fonts[sheet][key] = font
-
-    @cell[sheet][key] =
-      case value_type
-      when :float
-        v.to_f
-      when :string
-        v
-      when :date
-        v
-      when :datetime
-        @cell[sheet][key] = DateTime.new(v.year,v.month,v.day,v.hour,v.min,v.sec)
-      when :percentage
-        v.to_f
-      when :time
-        v
-      else
-        v
-      end
-  end
-
-  # ruby-spreadsheet has a font object so we're extending it
-  # with our own functionality but still providing full access
-  # to the user for other font information
-  module ExcelFontExtensions
-    def bold?(*args)
-      #From ruby-spreadsheet doc: 100 <= weight <= 1000, bold => 700, normal => 400
-      weight == 700
-    end
-
-    def italic?
-      italic
-    end
-
-    def underline?
-      underline != :none
-    end
-  end
-
-  # read all cells in the selected sheet
-  def read_cells(sheet=nil)
-    sheet ||= @default_sheet
-    validate_sheet!(sheet)
-    return if @cells_read[sheet]
-
-    worksheet = @workbook.worksheet(sheet_no(sheet))
-    row_index=1
-    worksheet.each(0) do |row|
-      (0..row.size).each do |cell_index|
-        cell = row.at(cell_index)
-        next if cell.nil?  #skip empty cells
-        next if cell.class == Spreadsheet::Formula && cell.value.nil? # skip empty formula cells
-        value_type, v =
-          if date_or_time?(row, cell_index)
-            read_cell_date_or_time(row, cell_index)
-          else
-            read_cell(row, cell_index)
-          end
-        formula = tr = nil #TODO:???
-        col_index = cell_index + 1
-        font = row.format(cell_index).font
-        font.extend(ExcelFontExtensions)
-        set_cell_values(sheet,row_index,col_index,0,v,value_type,formula,tr,font)
-      end #row
-      row_index += 1
-    end # worksheet
-    @cells_read[sheet] = true
-  end
-
-  # Get the contents of a cell, accounting for the
-  # way formula stores the value
-  def read_cell_content(row, idx)
-    cell = row.at(idx)
-    cell = row[idx] if row[idx].class == Spreadsheet::Link
-    cell = cell.value if cell.class == Spreadsheet::Formula
-    cell
-  end
-
-  # Test the cell to see if it's a valid date/time.
-  def date_or_time?(row, idx)
-    format = row.format(idx)
-    if format.date_or_time?
-      cell = read_cell_content(row, idx)
-      true if Float(cell) > 0 rescue false
-    else
-      false
-    end
-  end
-
-  # Read the date-time cell and convert to,
-  # the date-time values for Roo
-  def read_cell_date_or_time(row, idx)
-    cell = read_cell_content(row, idx)
-    cell = cell.to_s.to_f
-    if cell < 1.0
-      value_type = :time
-      f = cell*24.0*60.0*60.0
-      secs = f.round
-      h = (secs / 3600.0).floor
-      secs = secs - 3600*h
-      m = (secs / 60.0).floor
-      secs = secs - 60*m
-      s = secs
-      value = h*3600+m*60+s
-    else
-      if row.at(idx).class == Spreadsheet::Formula
-        datetime = row.send(:_datetime, cell)
-      else
-        datetime = row.datetime(idx)
-      end
-      if datetime.hour != 0 or
-          datetime.min != 0 or
-          datetime.sec != 0
-        value_type = :datetime
-        value = datetime
-      else
-        value_type = :date
-        if row.at(idx).class == Spreadsheet::Formula
-          value = row.send(:_date, cell)
-        else
-          value = row.date(idx)
-        end
-        value = sprintf("%04d-%02d-%02d",value.year,value.month,value.day)
-      end
-    end
-    return value_type, value
-  end
-
-  # Read the cell and based on the class,
-  # return the values for Roo
-  def read_cell(row, idx)
-    cell = read_cell_content(row, idx)
-    case cell
-    when Float, Integer, Fixnum, Bignum
-      value_type = :float
-      value = cell.to_f
-    when Spreadsheet::Link
-      value_type = :link
-      value = cell
-    when String, TrueClass, FalseClass
-      value_type = :string
-      value = cell.to_s
-    else
-      value_type = cell.class.to_s.downcase.to_sym
-      value = nil
-    end # case
-    return value_type, value
-  end
-
-end