roo 1.13.2 → 2.0.1

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

data/lib/roo/roo_rails_helper.rb

@@ -1,83 +0,0 @@
-warn "Roo's roo_rails_helper, aka the spreadsheet view method is currently deprecated with no replacement. If you find it helpful, tell http://github.com/Empact or extract it yourself."
-def spreadsheet(spreadsheet, sheets, options={})
-  @rspreadsheet = spreadsheet
-  coordinates = true # default
-  o=""
-  if options[:coordinates] != nil
-    o << ":coordinates uebergeben: #{options[:coordinates]}"
-    coordinates = options[:coordinates]
-  end
-  if options[:bgcolor]
-    bgcolor = options[:bgcolor]
-  else
-    bgcolor = false
-  end
-
-  sheets.each { |sheet|
-    @rspreadsheet.default_sheet = sheet
-    linenumber = @rspreadsheet.first_row(sheet)
-    if options[:first_row]
-      linenumber += (options[:first_row]-1)
-    end
-    o << '<table border="0" cellspacing="1" cellpadding="1">'
-    if options[:first_row]
-      first_row = options[:first_row]
-    end
-    if options[:last_row]
-      last_row = options[:last_row]
-    end
-    if options[:first_column]
-      first_column = options[:first_column]
-    end
-    if options[:last_column]
-      last_column = options[:last_column]
-    end
-    first_row    = @rspreadsheet.first_row(sheet) unless first_row
-    last_row     = @rspreadsheet.last_row(sheet) unless last_row
-    first_column = @rspreadsheet.first_column(sheet) unless first_column
-    last_column  = @rspreadsheet.last_column(sheet) unless last_column
-    if coordinates
-      o << "  <tr>"
-      o << "  <td>&nbsp;</td>"
-      @rspreadsheet.first_column(sheet).upto(@rspreadsheet.last_column(sheet)) {|c|
-        if c < first_column or c > last_column
-          next
-        end
-        o << "    <td>"
-        o << "      <b>#{Roo::Base.number_to_letter(c)}</b>"
-        o << "    </td>"
-      }
-      o << "</tr>"
-    end
-    @rspreadsheet.first_row.upto(@rspreadsheet.last_row) do |y|
-      if first_row and (y < first_row or y > last_row)
-        next
-      end
-      o << "<tr>"
-      if coordinates
-        o << "<td><b>#{linenumber.to_s}</b></td>"
-      end
-      linenumber += 1
-      @rspreadsheet.first_column(sheet).upto(@rspreadsheet.last_column(sheet)) do |x|
-        if x < first_column or x > last_column
-          next
-        end
-        if bgcolor
-          o << "<td bgcolor=\"#{bgcolor}\">"
-        else
-          o << '<td bgcolor="lightgreen">'
-        end
-        if @rspreadsheet.cell(y,x).to_s.empty?
-          o << "&nbsp;"
-        else
-          o << "#{@rspreadsheet.cell(y,x)}"
-        end
-        o << "</td>"
-      end
-      o << "</tr>"
-    end
-    o << "</table>"
-  } # each sheet
-  return o
-end
-

data/lib/roo/worksheet.rb

@@ -1,18 +0,0 @@
-# patch for skipping blank rows in the case of
-# having a spreadsheet with 30,000 nil rows appended
-# to the actual data.  (it happens and your RAM will love me)
-class Spreadsheet::Worksheet
-
-  def each skip=dimensions[0]
-    blanks = 0
-    skip.upto(dimensions[1] - 1) do |i|
-      if row(i).any?
-        Proc.new.call(row(i))
-      else
-        blanks += 1
-        blanks < 20 ? next : return
-      end
-    end
-  end
-
-end

data/scripts/txt2html

@@ -1,67 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'redcloth'
-require 'syntax/convertors/html'
-require 'erb'
-require File.dirname(__FILE__) + '/../lib/roo/version.rb'
-
-version  = Roo::VERSION::STRING
-download = 'http://rubyforge.org/projects/roo'
-
-class Fixnum
-  def ordinal
-    # teens
-    return 'th' if (10..19).include?(self % 100)
-    # others
-    case self % 10
-    when 1: return 'st'
-    when 2: return 'nd'
-    when 3: return 'rd'
-    else    return 'th'
-    end
-  end
-end
-
-class Time
-  def pretty
-    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
-  end
-end
-
-def convert_syntax(syntax, source)
-  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
-end
-
-if ARGV.length >= 1
-  src, template = ARGV
-  template ||= File.dirname(__FILE__) + '/../website/template.rhtml'
-  
-else
-  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
-  exit!
-end
-
-template = ERB.new(File.open(template).read)
-
-title = nil
-body = nil
-File.open(src) do |fsrc|
-  title_text = fsrc.readline
-  body_text = fsrc.read
-  syntax_items = []
-  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</
>!m){
-    ident = syntax_items.length
-    element, syntax, source = $1, $2, $3
-    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
-    "syntax-temp-#{ident}"
-  }
-  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
-  body = RedCloth.new(body_text).to_html
-  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
-end
-stat = File.stat(src)
-created = stat.ctime
-modified = stat.mtime
-
-$stdout << template.result(binding)

data/spec/lib/roo/excel2003xml_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Roo::Excel2003XML do
-  describe '.new' do
-    context 'with an xml file' do
-      let(:path) { 'test/files/datetime.xml' }
-
-      it 'loads the file' do
-        expect {
-          Roo::Excel2003XML.new(path)
-        }.to_not raise_error
-      end
-    end
-  end
-end

data/spec/lib/roo/excel_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Roo::Excel do
-  let(:excel) { Roo::Excel.new('test/files/boolean.xls') }
-
-  describe '.new' do
-    it 'creates an instance' do
-      expect(excel).to be_a(Roo::Excel)
-    end
-  end
-
-  describe '#sheets' do
-    it 'returns the sheet names of the file' do
-      expect(excel.sheets).to eq(["Sheet1", "Sheet2", "Sheet3"])
-    end
-  end
-end

data/spec/lib/roo/google_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe Roo::Google do
-  let(:key) { '0AiokXJytm-hjdDhYbTNvZ3pDWm9oZm9yWURLX3ZoR2c' }
-
-  describe '.new' do
-    context 'given a username and password' do
-      let(:user) { 'user' }
-      let(:password) { 'password' }
-
-      subject {
-        Roo::Google.new(key, user: user, password: password)
-      }
-
-      it 'creates an instance' do
-        VCR.use_cassette('google_drive') do
-          expect(subject).to be_a(Roo::Google)
-        end
-      end
-    end
-
-    context 'given an access token' do
-      let(:access_token) { 'ya29.AHES6ZR1kGjlmlLJG9skjpO0IjzQ6qDohXwFJclzD7mHI9xa-cFzlg' }
-
-      subject {
-        Roo::Google.new(key, access_token: access_token)
-      }
-
-      it 'creates an instance' do
-        VCR.use_cassette('google_drive_access_token') do
-          expect(subject).to be_a(Roo::Google)
-        end
-      end
-    end
-  end
-
-  describe '.set' do
-    let(:key) { '0AiVSev9-0p-PdEVrQldEY1I4dDJjVlpEQUkwblprcnc' }
-    let(:user) { 'user' }
-    let(:password) { "password" }
-
-    subject {
-      Roo::Google.new(key, user: user, password: password)
-    }
-
-    it 'records the value' do
-      VCR.use_cassette('google_drive_set') do
-        subject.cell(1, 1).should == '1x1'
-        subject.cell(1, 2).should == '1x2'
-        subject.cell(2, 1).should == '2x1'
-        subject.cell(2, 2).should == '2x2'
-        subject.set(1, 1, '1x1')
-        subject.set(1, 2, '1x2')
-        subject.set(2, 1, '2x1')
-        subject.set(2, 2, '2x2')
-        subject.cell(1, 1).should == '1x1'
-        subject.cell(1, 2).should == '1x2'
-        subject.cell(2, 1).should == '2x1'
-        subject.cell(2, 2).should == '2x2'
-      end 
-    end
-  end
-
-end