roo-rb / roo-xls / 45

pending completion

Build # 45

Build Type

push

travis-ci

Committed by

Empact

Commit Message

<a href="https://github.com/roo-rb/roo-xls/commit/<a class=hub.com/roo-rb/roo-xls/commit/<a class="double-link" href="https://git"><a class=hub.com/roo-rb/roo-xls/commit/d85e0944b9634477ad09d5e3ea7e6ce6b41edd67">d85e0944b<a href="https://github.com/roo-rb/roo-xls/commit/d85e0944b9634477ad09d5e3ea7e6ce6b41edd67">&lt;a href=&quot;https://github.com/roo-rb/roo-xls/commit/d85e0944b9634477ad09d5e3ea7e6ce6b41edd67">&quot;&gt;Revert &amp;quot;Merge pull request #10 from scottwillson/preserve-fractional-seconds&amp;quot;

This reverts commit &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/roo-rb/roo-xls/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/roo-rb/roo-xls/commit/3671caacced0c47f0436b8af18d1deb260cc5ca5">3671caacc</a>">3671caacc</a><a href="https://github.com/roo-rb/roo-xls/commit/d85e0944b9634477ad09d5e3ea7e6ce6b41edd67">, reversing
changes made to </a><a class="double-link" href="https://github.com/roo-rb/roo-xls/commit/<a class="double-link" href="https://github.com/roo-rb/roo-xls/commit/4b81418cda5e7ed1bae42205bd6b7c8b006fd1b7">4b81418cd">4b81418cd.

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

314 of 393 relevant lines covered (79.9%)

3389.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.77

/lib/roo/xls/excel.rb

require 'roo/xls/version'
require 'roo/base'
require 'spreadsheet'
require 'tmpdir'

module Roo
  # Class for handling Excel-Spreadsheets
  class Excel < Roo::Base
    FORMULAS_MESSAGE = 'the spreadsheet gem does not support formulas, 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 = {})
      packed = options[:packed]
      file_warning = options[:file_warning] || :error
      mode = options[:mode] || 'rb+'

      if is_stream?(filename)
        @workbook = ::Spreadsheet.open(filename, mode)
      else
        file_type_check(filename, '.xls', 'an Excel', file_warning, packed)
        Dir.mktmpdir do |tmpdir|
          filename = download_uri(filename, tmpdir) if uri?(filename)
          filename = open_from_stream(filename[7..-1], tmpdir) if filename.is_a?(::String) && filename[0, 7] == 'stream:'
          filename = unzip(filename, tmpdir) if packed == :zip

          @filename = filename
          unless File.file?(@filename)
            fail IOError, "file #{@filename} does not exist"
          end
          @workbook = ::Spreadsheet.open(filename, mode)
        end
      end

      super(filename, options)
      @formula = {}
      @fonts = {}
    end

    attr_reader :workbook

    def worksheets
      @worksheets ||= workbook.worksheets
    end

    def encoding=(codepage)
      @workbook.encoding = codepage
    end

    # returns an array of sheet names in the spreadsheet
    def sheets
      @sheets ||= worksheets.collect { |worksheet| normalize_string(worksheet.name) }
    end

    # this method lets you find the worksheet with the most data
    def longest_sheet
      sheet(worksheets.inject do|m, o|
        o.row_count > m.row_count ? o : m
      end.name)
    end

    # returns the content of a cell. The upper left corner is (1,1) or ('A',1)
    def cell(row, col, sheet = default_sheet)
      validate_sheet!(sheet)

      read_cells(sheet)
      fail '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] && @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 = default_sheet)
      read_cells(sheet)
      row, col = normalize(row, col)
      begin
        if @formula[sheet] && @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)
      fail NotImplementedError, FORMULAS_MESSAGE
    end
    alias_method :formula?, :formula

    # returns NO formulas in excel spreadsheets
    def formulas(_sheet = nil)
      fail NotImplementedError, FORMULAS_MESSAGE
    end

    # Given a cell, return the cell's font
    def font(row, col, 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 = 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.is_a?(Integer)
      i = 0
      worksheets.each do |worksheet|
        return i if name == normalize_string(worksheet.name)
        i += 1
      end
      fail 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 = 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 ||
           datetime.min != 0 ||
           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
      [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
        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
      [value_type, value]
    end
  end
end

1	require 'roo/xls/version'	14✔
2	require 'roo/base'	14✔
3	require 'spreadsheet'	14✔
4	require 'tmpdir'	14✔
5
6	module Roo	14✔
7	# Class for handling Excel-Spreadsheets
8	class Excel < Roo::Base	14✔
9	FORMULAS_MESSAGE = 'the spreadsheet gem does not support formulas, so roo can not.'	14✔
10	CHARGUESS =	14✔
11	begin
12	require 'charguess'	14✔
13	true	×
14	rescue LoadError
15	false	14✔
16	end
17
18	attr_reader :workbook	14✔
19
20	# Creates a new Excel spreadsheet object.
21	# Parameter packed: :zip - File is a zip-file
22	def initialize(filename, options = {})	14✔
23	packed = options[:packed]	388✔
24	file_warning = options[:file_warning] \|\| :error	388✔
25	mode = options[:mode] \|\| 'rb+'	388✔
26
27	if is_stream?(filename)	388✔
28	@workbook = ::Spreadsheet.open(filename, mode)	6 all except jruby-19mode ✔
29	else
30	file_type_check(filename, '.xls', 'an Excel', file_warning, packed)	382✔
31	Dir.mktmpdir do \|tmpdir\|	354✔
32	filename = download_uri(filename, tmpdir) if uri?(filename)	354✔
33	filename = open_from_stream(filename[7..-1], tmpdir) if filename.is_a?(::String) && filename[0, 7] == 'stream:'	354✔
34	filename = unzip(filename, tmpdir) if packed == :zip	354✔
35
36	@filename = filename	354✔
37	unless File.file?(@filename)	354✔
38	fail IOError, "file #{@filename} does not exist"	8✔
39	end
40	@workbook = ::Spreadsheet.open(filename, mode)	347✔
41	end
42	end
43
44	super(filename, options)	339✔
45	@formula = {}	339✔
46	@fonts = {}	339✔
47	end
48
49	attr_reader :workbook	14✔
50
51	def worksheets	14✔
52	@worksheets \|\|= workbook.worksheets	789✔
53	end
54
55	def encoding=(codepage)	14✔
56	@workbook.encoding = codepage	×
57	end
58
59	# returns an array of sheet names in the spreadsheet
60	def sheets	14✔
61	@sheets \|\|= worksheets.collect { \|worksheet\| normalize_string(worksheet.name) }	52,716✔
62	end
63
64	# this method lets you find the worksheet with the most data
65	def longest_sheet	14✔
66	sheet(worksheets.inject do\|m, o\|	×
67	o.row_count > m.row_count ? o : m	×
68	end.name)
69	end
70
71	# returns the content of a cell. The upper left corner is (1,1) or ('A',1)
72	def cell(row, col, sheet = default_sheet)	14✔
73	validate_sheet!(sheet)	8,623✔
74
75	read_cells(sheet)	8,623✔
76	fail 'should be read' unless @cells_read[sheet]	8,623✔
77	row, col = normalize(row, col)	8,623✔
78	if celltype(row, col, sheet) == :date	8,623✔
79	yyyy, mm, dd = @cell[sheet][[row, col]].split('-')	596✔
80	return Date.new(yyyy.to_i, mm.to_i, dd.to_i)	596✔
81	end
82	if celltype(row, col, sheet) == :string	8,027✔
83	return platform_specific_encoding(@cell[sheet][[row, col]])	1,478✔
84	else
85	if @cell[sheet] && @cell[sheet][[row, col]]	6,549✔
86	return @cell[sheet][[row, col]]	2,740✔
87	else
88	return nil	5 only jruby-19mode ✔
89	end
90	end
91	end
92
93	# returns the type of a cell:
94	# * :float
95	# * :string,
96	# * :date
97	# * :percentage
98	# * :formula
99	# * :time
100	# * :datetime
101	def celltype(row, col, sheet = default_sheet)	14✔
102	read_cells(sheet)	19,814✔
103	row, col = normalize(row, col)	19,814✔
104	begin	19,814✔
105	if @formula[sheet] && @formula[sheet][[row, col]]	19,814✔
106	:formula	×
107	elsif @cell_type[sheet]	19,704 all except jruby-19mode ✔
108	@cell_type[sheet][[row, col]]	19,814✔
109	end
110	rescue
111	puts "Error in sheet #{sheet}, row #{row}, col #{col}"	×
112	raise	×
113	end
114	end
115
116	# returns NO formula in excel spreadsheets
117	def formula(_row, _col, _sheet = nil)	14✔
118	fail NotImplementedError, FORMULAS_MESSAGE	14✔
119	end
120	alias_method :formula?, :formula	14✔
121
122	# returns NO formulas in excel spreadsheets
123	def formulas(_sheet = nil)	14✔
124	fail NotImplementedError, FORMULAS_MESSAGE	7✔
125	end
126
127	# Given a cell, return the cell's font
128	def font(row, col, sheet = default_sheet)	14✔
129	read_cells(sheet)	231✔
130	row, col = normalize(row, col)	231✔
131	@fonts[sheet][[row, col]]	231✔
132	end
133
134	# shows the internal representation of all cells
135	# mainly for debugging purposes
136	def to_s(sheet = default_sheet)	14✔
137	read_cells(sheet)	×
138	@cell[sheet].inspect	×
139	end
140
141	private	14✔
142
143	# converts name of a sheet to index (0,1,2,..)
144	def sheet_no(name)	14✔
145	return name - 1 if name.is_a?(Integer)	514✔
146	i = 0	514✔
147	worksheets.each do \|worksheet\|	514✔
148	return i if name == normalize_string(worksheet.name)	1,003✔
149	i += 1	489✔
150	end
151	fail StandardError, "sheet '#{name}' not found"	×
152	end
153
154	def normalize_string(value)	14✔
155	value = every_second_null?(value) ? remove_every_second_null(value) : value	1,824✔
156	if CHARGUESS && encoding = CharGuess.guess(value)	1,824✔
157	encoding.encode Encoding::UTF_8	×
158	else
159	platform_specific_encoding(value)	1,824✔
160	end
161	end
162
163	def platform_specific_encoding(value)	14✔
164	result =	3,300✔
165	case RUBY_PLATFORM.downcase
166	when /darwin\|solaris/	54 only jruby-19mode ✔
167	value.encode Encoding::UTF_8	×
168	when /mswin32/	54 only jruby-19mode ✔
169	value.encode Encoding::ISO_8859_1	×
170	else
171	value	3,300✔
172	end
173	if every_second_null?(result)	3,300✔
174	result = remove_every_second_null(result)	×
175	end
176	result	3,300✔
177	end
178
179	def every_second_null?(str)	14✔
180	result = true	5,077✔
181	return false if str.length < 2	5,077✔
182	0.upto(str.length / 2 - 1) do \|i\|	4,969✔
183	if str[i * 2 + 1, 1] != "\000"	4,969✔
184	result = false	4,969✔
185	break	4,969✔
186	end
187	end
188	result	4,969✔
189	end
190
191	def remove_every_second_null(str)	14✔
192	result = ''	×
193	0.upto(str.length / 2 - 1) do \|i\|	×
194	c = str[i * 2, 1]	×
195	result += c	×
196	end
197	result	×
198	end
199
200	# helper function to set the internal representation of cells
201	def set_cell_values(sheet, row, col, i, v, value_type, formula, _tr, font)	14✔
202	# key = "#{y},#{x+i}"
203	key = [row, col + i]	24,934✔
204	@cell_type[sheet] = {} unless @cell_type[sheet]	24,934✔
205	@cell_type[sheet][key] = value_type	24,934✔
206	@formula[sheet] = {} unless @formula[sheet]	24,934✔
207	@formula[sheet][key] = formula if formula	24,934✔
208	@cell[sheet] = {} unless @cell[sheet]	24,934✔
209	@fonts[sheet] = {} unless @fonts[sheet]	24,934✔
210	@fonts[sheet][key] = font	24,934✔
211
212	@cell[sheet][key] =	24,934✔
213	case value_type
214	when :float	106 only jruby-19mode ✔
215	v.to_f	13,142✔
216	when :string	68 only jruby-19mode ✔
217	v	10,777✔
218	when :date	25 only jruby-19mode ✔
219	v	734✔
220	when :datetime	17 only jruby-19mode ✔
221	@cell[sheet][key] = DateTime.new(v.year, v.month, v.day, v.hour, v.min, v.sec)	194✔
222	when :percentage	3 only jruby-19mode ✔
223	v.to_f	×
224	when :time	3 only jruby-19mode ✔
225	v	75✔
226	else
227	v	12 all except jruby-19mode ✔
228	end
229	end
230
231	# ruby-spreadsheet has a font object so we're extending it
232	# with our own functionality but still providing full access
233	# to the user for other font information
234	module ExcelFontExtensions	14✔
235	def bold?(*_args)	14✔
236	# From ruby-spreadsheet doc: 100 <= weight <= 1000, bold => 700, normal => 400
237	weight == 700	77✔
238	end
239
240	def italic?	14✔
241	italic	77✔
242	end
243
244	def underline?	14✔
245	underline != :none	77✔
246	end
247	end
248
249	# read all cells in the selected sheet
250	def read_cells(sheet = default_sheet)	14✔
251	validate_sheet!(sheet)	42,643✔
252	return if @cells_read[sheet]	42,643✔
253
254	worksheet = @workbook.worksheet(sheet_no(sheet))	463✔
255	row_index = 1	463✔
256	worksheet.each(0) do \|row\|	463✔
257	(0..row.size).each do \|cell_index\|	7,318✔
258	cell = row.at(cell_index)	66,981✔
259	next if cell.nil? # skip empty cells	66,981✔
260	next if cell.class == ::Spreadsheet::Formula && cell.value.nil? # skip empty formula cells	24,847✔
261	value_type, v =	24,847✔
262	if date_or_time?(row, cell_index)	12,414 only 2.4.0, 2.3, and ruby-head ✔
263	read_cell_date_or_time(row, cell_index)	997✔
264	else
265	read_cell(row, cell_index)	23,850 all except jruby-19mode ✔
266	end
267	formula = tr = nil # TODO:???	24,847✔
268	col_index = cell_index + 1	24,847✔
269	font = row.format(cell_index).font	24,847✔
270	font.extend(ExcelFontExtensions)	24,847✔
271	set_cell_values(sheet, row_index, col_index, 0, v, value_type, formula, tr, font)	24,847✔
272	end # row
273	row_index += 1	7,310✔
274	end # worksheet
275	@cells_read[sheet] = true	463✔
276	end
277
278	# Get the contents of a cell, accounting for the
279	# way formula stores the value
280	def read_cell_content(row, idx)	14✔
281	cell = row.at(idx)	25,905✔
282	cell = row[idx] if row[idx].class == ::Spreadsheet::Link	25,905✔
283	cell = cell.value if cell.class == ::Spreadsheet::Formula	25,905✔
284	cell	25,905✔
285	end
286
287	# Test the cell to see if it's a valid date/time.
288	def date_or_time?(row, idx)	14✔
289	format = row.format(idx)	24,892✔
290	if format.date_or_time?	24,892✔
291	cell = read_cell_content(row, idx)	1,051✔
292	true if Float(cell) > 0 rescue false	1,099✔
293	else
294	false	23,841✔
295	end
296	end
297
298	# Read the date-time cell and convert to,
299	# the date-time values for Roo
300	def read_cell_date_or_time(row, idx)	14✔
301	cell = read_cell_content(row, idx)	1,032✔
302	cell = cell.to_s.to_f	1,032✔
303	if cell < 1.0	1,032✔
304	value_type = :time	75✔
305	f = cell * 24.0 * 60.0 * 60.0	75✔
306	secs = f.round	75✔
307	h = (secs / 3600.0).floor	78✔
308	secs = secs - 3600 * h	75✔
309	m = (secs / 60.0).floor	78✔
310	secs = secs - 60 * m	75✔
311	s = secs	75✔
312	value = h * 3600 + m * 60 + s	75✔
313	else
314	if row.at(idx).class == ::Spreadsheet::Formula	957✔
315	datetime = row.send(:_datetime, cell)	60 all except jruby-19mode ✔
316	else
317	datetime = row.datetime(idx)	897✔
318	end
319	if datetime.hour != 0 \|\|	51 only jruby-19mode ✔
320	datetime.min != 0 \|\|	906 all except jruby-19mode ✔
321	datetime.sec != 0
322	value_type = :datetime	194✔
323	value = datetime	194✔
324	else
325	value_type = :date	763✔
326	if row.at(idx).class == ::Spreadsheet::Formula	763✔
327	value = row.send(:_date, cell)	36 all except jruby-19mode ✔
328	else
329	value = row.date(idx)	727✔
330	end
331	value = sprintf('%04d-%02d-%02d', value.year, value.month, value.day)	763✔
332	end
333	end
334	[value_type, value]	1,032✔
335	end
336
337	# Read the cell and based on the class,
338	# return the values for Roo
339	def read_cell(row, idx)	14✔
340	cell = read_cell_content(row, idx)	23,981✔
341	case cell	23,981✔
342	when Float, Integer	184 only jruby-19mode ✔
343	value_type = :float	13,182✔
344	value = cell.to_f	13,182✔
345	when ::Spreadsheet::Link	53 only jruby-19mode ✔
346	value_type = :link	12 all except jruby-19mode ✔
347	value = cell	12 all except jruby-19mode ✔
348	when String, TrueClass, FalseClass	53 only jruby-19mode ✔
349	value_type = :string	10,787✔
350	value = cell.to_s	10,787✔
351	else
352	value_type = cell.class.to_s.downcase.to_sym	×
353	value = nil	×
354	end # case
355	[value_type, value]	23,981✔
356	end
357	end
358	end

roo-rb / roo-xls / 45

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous