oxcelix 0.2.4 → 0.3.0

data/CHANGES

@@ -1,64 +1,21 @@
- * Fixed serious regression which was preventing the copy-merge routine from properly run (cols and rows were flipped). Fixed smaller bug which caused comments to be inserted as a 1-element array of hashes instead of plain text.
- Thu Oct 10 23:44:39 2013 +0200
- * Fixed major bug which prevented the comments to be pulled from the XML files.
- Thu Oct 10 20:12:56 2013 +0200
- * Fixed serious bug concerning the loading of the worksheets. Oxcelix will now correctly guess the filenames of the XML files describing the sheets
- Thu Oct 10 18:22:39 2013 +0200
- * Update workbook.rb Wed Oct 9 19:10:39 2013 +0200
- * Changed another instance of Ox::load_file, as it won't work under windows Wed Oct 9 18:59:50 2013 +0200
- * The sheet class now inherits Matrix. Sheet can return a cell based on its excel name. Sheet::data is obsolete - deleted. Moved r, v, s to the Cellvalues module - they are not needed elsewhere but the Cell class. Documentation changes. .yardopts file added.
- Tue Oct 8 23:10:25 2013 +0200
- * The sheet class now inherits Matrix. Sheet can return a cell based on its excel name. Sheet::data is obsolete - deleted. Moved r, v, s to the Cellvalues module - they are not needed elsewhere but the Cell class. Documentation changes. .yardopts file added.
- Tue Oct 8 23:07:10 2013 +0200
- * slight documentation changes, yard options added to (protected and private methods docs are now readable)
- Tue Oct 8 20:17:29 2013 +0200
- * Changed gem version Mon Oct 7 22:12:34 2013 +0200
- * Removed sharedstrings and sheetbase properties as they were useless. Docs updated with the change. Mon Oct 7 18:15:44 2013 +0200
- * Update oxcelix.gemspec Mon Oct 7 17:48:14 2013 +0200
- * Update oxcelix.gemspec
-
-Raised visibility in rdoc, so that all method documentation gets readable. Mon Oct 7 17:47:50 2013 +0200
- * Update workbook.rb
-
-replaced Ox::load_file with IO.read + Ox::load in workbook, as apparently workbook.xml could not be loaded under windows using that method Mon Oct 7 17:37:39 2013 +0200
- * Minor typos corrected, added gemspec
- Sun Oct 6 16:52:54 2013 +0200
- * oxcelix.rb was not added to previous commit
- Sun Oct 6 12:29:37 2013 +0200
- * Broke down oxcelix.rb. Improved YARD documentation.
- Sun Oct 6 12:25:59 2013 +0200
- * Removed unneeded method from Xlsheet. Started converting docs to YARD
- Sat Oct 5 09:20:31 2013 +0200
- * Merge branch 'master' of https://github.com/gbiczo/oxcelix
- Wed Oct 2 00:19:54 2013 +0200
- * Repeating commit as the sheetdata method code was not included. Now it will simply do some Array magic to return the list of active sheets.
- Wed Oct 2 00:19:18 2013 +0200
- * Update README.md
-
-Fixed typos Wed Oct 2 00:08:00 2013 +0200
- * Merge branch 'master' of https://github.com/gbiczo/oxcelix
- Tue Oct 1 23:51:13 2013 +0200
- * Moved source to lib directory.
- Tue Oct 1 23:43:53 2013 +0200
- * Added README
- Tue Oct 1 23:42:27 2013 +0200
- * Added tests, recreated include-exclude code, now it works fine. Created README.rdoc
- Tue Oct 1 23:42:00 2013 +0200
- * Update README.md
-
-Corrected typo Tue Oct 1 23:32:22 2013 +0200
- * Update README.md Tue Oct 1 23:31:47 2013 +0200
- * Initial commit
- Tue Oct 1 14:21:10 2013 -0700
- * Really deleted the last few lines of code.
- Sat Sep 28 15:49:06 2013 +0200
- * Wrapper module Oxcelix created. String, Matrix, Fixnum are not included. Sheet objects are now created as a last step instead og the simple hashes. Workbookhelper module added, with one method, [](sheetname), which accepts a string parameter and returns the sheet named sheetname. Code cleanups (especially the last lines of the code which were there only for testing purposes.)
- Sat Sep 28 15:46:56 2013 +0200
- * Corrected Cellhelper::x() and Cellhelper::y() methods, now both return correct values. RDoc documentation added.
- Wed Sep 25 23:44:07 2013 +0200
- * Added support for sheet inclusion and exclusion. Workbook#new now accepts a hash of parameters, which may contain: :copymerge (Bool), :include_sheets (Ary), :exclude_sheets (Ary)
- Wed Sep 25 09:49:42 2013 +0200
- * Added col_name to display excel column names. Style data of cell is now included. X and Y may get parameters. The Workbook constructor will now unzip and process the excel file. All sheets get converted to matrices. Upon the Array->Matrix conversion, the merged cells max be omitted or repeated.
- Mon Sep 23 20:32:25 2013 +0200
- * First gitted version.
- Thu Aug 29 09:14:59 2013 +0200
+* Further code cleanup in numformats.rb Tue Dec 3 19:49:03 2013 +0100
+* Renamed add to add_custom_formats Tue Dec 3 19:46:15 2013 +0100
+* Path cleanup Tue Dec 3 19:07:47 2013 +0100
+* Added documentation to Formatarray. Fixed bug which prevented cells containing e.g. String values AND datetime/numeric formatting code to be properly returned when to_ru or to_fmt was invoked. Code cleanup. Tue Dec 3 19:06:39 2013 +0100
+* Numberhelper included in Cell class. Various typos corrected. Cell#to_ru and Cell#to_fmt now reflect the inclusion of the Numberformats module. Mon Dec 2 23:27:52 2013 +0100
+* to_ru and to_fmt methods are now encapsulated in the Numhelper method. This is not only cleaner, ensures them to be included in Cell and only there. Mon Dec 2 23:04:13 2013 +0100
+* Cleared @numformats from Workbook. Formatarray is now a Numformats module constant available to any class including it. Mon Dec 2 22:47:40 2013 +0100
+* Numformat is now included in Workbook. Dtmap became a constant. New method Numformats::add converts the temparray to a series of numformat hashes and adds it to the main numformat array. to_ru, to_fmt, datetime, numeric are now Workbook methods. Slight code cleanup. Sun Dec 1 19:28:41 2013 +0100
+* Numformats.rb cleanup. Documented new modules/methods. Restructured to_ru and to_fmt. Fri Nov 29 09:23:41 2013 +0100
+* Code cleanup. TODO: split format string (;)? cellhelper.rb to be cleaned up Mon Nov 25 00:06:38 2013 +0100
+* finalized numeric method with a regex composed by 6 members: prefix, decimals, separator, floats, expo, postfix. This obsoletes the vgrp method as well as the other ones (still in the numformats.rb file.) TODO: delete all unnecessary code and provide a meaningful return value. Mon Nov 25 00:00:52 2013 +0100
+* Added Numformats Sat Nov 23 09:48:50 2013 +0100
+* Merge branch '0.3.0' of https://github.com/gbiczo/oxcelix into 0.3.0 Sat Nov 23 09:43:59 2013 +0100
+* Added numformats.rb. Cleaned styles.rb from unnecessary comments. Sat Nov 23 09:41:10 2013 +0100
+* Added badge Fri Nov 22 12:20:48 2013 +0100
+* Some speed optimizations. matrixto does not accept fmt parameter any more. fixed typos Wed Nov 13 00:03:44 2013 +0100
+* Cell now has a numformat attribute. A new module called Numformats will contain methods related to numeric formatting. to_r and to_d are now obsolete. Xlsheet init parameter (styles). Stylefile is opened in the workbook. Matrixto gets a :values option (this will be obsoleted shortly). Slight Gemspec and .md description change Mon Nov 4 17:47:17 2013 +0100
+* Initial version of Sheet::to_m method Sat Oct 19 11:06:42 2013 +0200
+* Format array is now a constant (FARY) Fri Oct 18 21:58:39 2013 +0200
+* Fixed typo in README Fri Oct 18 21:51:09 2013 +0200
+* Started working on cell value formats Fri Oct 18 21:50:24 2013 +0200

data/README.rdoc

@@ -1,12 +1,14 @@
 = \Oxcelix - A fast .xlsx file parser
 
+{<img src="https://badge.fury.io/rb/oxcelix.png" alt="Gem Version" />}[http://badge.fury.io/rb/oxcelix]
+
 == Description
 
 Oxcelix is an xlsx (Excel 2007/2010) parser. The result of the parsing is a
 Workbook which is an array of Sheet objects, which in turn store the data in
 Matrix objects. Matrices consist of Cell objects to maintain comments and
-formatting/style data
-.
+formatting/style data.
+
 Oxcelix uses the great Ox gem (http://rubygems.org/gems/ox) for fast SAX-parsing.
 
 == Synopsis
@@ -27,4 +29,4 @@ To include only some of the sheets:
 
 To have the values of the merged cells copied over the mergegroup:
 
-  w = Oxcelix::Workbook.new('whatever.xlsx', :mergecells => true)
+  w = Oxcelix::Workbook.new('whatever.xlsx', :copymerge => true)

data/lib/oxcelix/cell.rb

@@ -10,9 +10,13 @@ module Oxcelix
   #   @return [String] Comment text
   # @!attribute [rw] style
   #   @return [String] Excel style attribute
+  # @!attribute [rw] numformat
+  #   @return [String] Excel style number formatting
+
   class Cell
-    attr_accessor :xlcoords, :type, :value, :comment, :style
+    attr_accessor :xlcoords, :type, :value, :comment, :style, :numformat
     include Cellhelper
     include Cellvalues
+    include Numberhelper
   end
 end

data/lib/oxcelix/cellhelper.rb

@@ -1,6 +1,7 @@
-
 module Oxcelix
-  # The Cellhelper module defines some methods useful to manipulate Cell objects
+
+  # The Cellvalues module provides methods for setting cell values. They are named after the relevant XML entitiesd and 
+  # called directly by the Xlsheet SAX parser.
   module Cellvalues
     # Set the excel cell name (eg: 'A2')
     # @param [String] val Excel cell address name
@@ -13,6 +14,7 @@ module Oxcelix
     def s(val); @style = val; end;
   end
   
+  # The Cellhelper module defines some methods useful to manipulate Cell objects
   module Cellhelper
     # When called without parameters, returns the x coordinate of the calling cell object based on the value of #@xlcoords
     # If a parameter is given, #x will return the x coordinate corresponding to the parameter

data/lib/oxcelix/nf.rb

@@ -0,0 +1,172 @@
+module Oxcelix
+  module Numformats
+  	# Formatarray is the array of default format strings in Excel. Nil values should apparently contain CJK date format strings, 
+  	#feel free to add/document those according to existing standards. 
+  	Formatarray = [
+  	  	{:id => '0', :xl => 'General', :ostring => nil, :cls => 'string'},
+		{:id => '1', :xl => '0', :ostring => '%1d', :cls => 'numeric'},
+		{:id => '2', :xl => '0.00', :ostring => '%1.2f', :cls => 'numeric'},
+		{:id => '3', :xl => '#,##0', :ostring => '%#4d', :cls => 'numeric'},
+		{:id => '4', :xl => '#,##0.00', :ostring => '%#4.2f', :cls => 'numeric'},
+		{:id => '5', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '6', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '7', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '8', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '9', :xl => '0%', :ostring => '%1d%', :cls => 'numeric'},
+		{:id => '10', :xl => '0.00%', :ostring => '%1.2f%', :cls => 'numeric'},
+		{:id => '11', :xl => '0.00E+00', :ostring => '%1.2fE+', :cls => 'numeric'},
+		{:id => '12', :xl => '# ?/?', :ostring => '%#1d', :cls => 'rational'},
+		{:id => '13', :xl => '# ??/??', :ostring => '%#1d', :cls => 'rational'},
+		{:id => '14', :xl => 'd/m/yyyy', :ostring => '%-d/%-m/%Y', :cls => 'date'},
+		{:id => '15', :xl => 'd-mmm-yy', :ostring => '%-d-%b-%y', :cls => 'date'},
+		{:id => '16', :xl => 'd-mmm', :ostring => '%-d-%b', :cls => 'date'},
+		{:id => '17', :xl => 'mmm-yy', :ostring => '%b-%y', :cls => 'date'},
+		{:id => '18', :xl => 'h:mm tt', :ostring => '%-k:%M tt', :cls => 'date'},
+		{:id => '19', :xl => 'h:mm:ss tt', :ostring => '%-k:%M:%-S tt', :cls => 'date'},
+		{:id => '20', :xl => 'H:mm', :ostring => '%-k:%M', :cls => 'date'},
+		{:id => '21', :xl => 'H:mm:ss', :ostring => '%-k:%M:%-S', :cls => 'date'},
+		{:id => '22', :xl => 'm/d/yyyy H:mm', :ostring => '%-m/%-d/%Y %-k:%M', :cls => 'date'},
+		{:id => '23', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '24', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '25', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '26', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '27', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '28', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '29', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '30', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '31', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '32', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '33', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '34', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '35', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '36', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '37', :xl => '#,##0 ;(#,##0)', :ostring => '%#4d', :cls => 'numeric'},
+		{:id => '38', :xl => '#,##0 ;[Red](#,##0)', :ostring => '%#4d', :cls => 'numeric'},
+		{:id => '39', :xl => '#,##0.00;(#,##0.00)', :ostring => '%#4.2f', :cls => 'numeric'},
+		{:id => '40', :xl => '#,##0.00;[Red](#,##0.00)', :ostring => '%#4.2f', :cls => 'numeric'},
+		{:id => '41', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '42', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '43', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '44', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '45', :xl => 'mm:ss', :ostring => '%M:%-S', :cls => 'date'},
+		{:id => '46', :xl => '[h]:mm:ss', :ostring => '%-k:%M:%-S', :cls => 'date'},
+		{:id => '47', :xl => 'mmss.0', :ostring => '%M%-S.%1n', :cls => 'date'},
+		{:id => '48', :xl => '##0.0E+0', :ostring => '%#3.1E', :cls => 'numeric'},
+		{:id => '49', :xl => '@,', :ostring => '@%d', :cls => 'numeric'},
+		{:id => '50', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '51', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '52', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '53', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '54', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '55', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '56', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '57', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '58', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '59', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '60', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '61', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '62', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '63', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '64', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '65', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '66', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '67', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '68', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '69', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '70', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '71', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '72', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '73', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '74', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '75', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '76', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '77', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '78', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '79', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '80', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '81', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '82', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '83', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '84', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '85', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '86', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '87', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '88', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '89', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '90', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '91', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '92', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '93', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '94', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '95', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '96', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '97', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '98', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '99', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '100', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '101', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '102', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '103', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '104', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '105', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '106', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '107', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '108', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '109', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '110', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '111', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '112', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '113', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '114', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '115', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '116', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '117', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '118', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '119', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '120', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '121', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '122', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '123', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '124', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '125', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '126', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '127', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '128', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '129', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '130', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '131', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '132', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '133', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '134', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '135', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '136', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '137', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '138', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '139', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '140', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '141', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '142', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '143', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '144', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '145', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '146', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '147', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '148', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '149', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '150', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '151', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '152', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '153', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '154', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '155', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '156', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '157', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '158', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '159', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '160', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '161', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '162', :xl => '', :ostring => nil, :cls => 'string'},
+		{:id => '163', :xl => '', :ostring => nil, :cls => 'string'},
+	  ]
+	end
+end

data/lib/oxcelix/numformats.rb

@@ -0,0 +1,105 @@
+module Oxcelix
+# The Numformats module provides helper methods that either return the Cell object's raw @value as a ruby value
+# (e.g. Numeric, DateTime, String) or formats it according to the excel _numformat_ string (#Cell.numformat).
+    module Numformats
+      Dtmap = {'hh'=>'%H', 'ii'=>'%M', 'i'=>'%-M', 'H'=>'%-k', 'h'=>'%-k',\
+                    'ss'=>'%-S', 's'=>'%S', 'mmmmm'=>'%b', 'mmmm'=>'%B', 'mmm'=>'%b', 'mm'=>'%m', \
+                    'm'=>'%-m', 'dddd'=>'%A', 'ddd'=>'%a', 'dd'=>'%d', 'd'=>'%-d', 'yyyy'=>'%Y', \
+                    'yy'=>'%y', 'AM/PM'=>'%p', 'A/P'=>'%p', '.0'=>'', 'ss'=>'%-S', 's'=>'%S'}
+
+      # Convert the temporary format array (the collection of non-default number formatting strings defined in the excel sheet in use)
+      # to a series of hashes containing an id, an excel format string, a converted format string and an object class the format is
+      # interpreted on.
+      def add_custom_formats fmtary
+        fmtary.each do |x|
+          if x[:formatCode] =~ /[#0%\?]/
+            ostring = numeric x[:formatCode]
+            if x[:formatCode] =~ /\//
+              cls = 'rational'
+            else
+              cls = 'numeric'
+            end
+          elsif x[:formatCode].downcase =~ /[dmysh]/
+            ostring = datetime x[:formatCode]
+            cls = 'date'
+          elsif x[:formatCode].downcase == "general"
+            ostring = nil
+            cls = 'string'
+          end
+          Formatarray << {:id => x[:numFmtId].to_s, :xl => x[:formatCode].to_s, :ostring => ostring, :cls => cls}
+        end
+      end
+      
+      # Convert the excel-style number format to a ruby #Kernel::Format string and return that String.
+      # The conversion is internally done by regexp'ing 7 groups: prefix, decimals, separator, floats, exponential (E+)
+      # and postfix. Rational numbers ar not handled yet.
+      # @param [String] val an Excel number format string.
+      # @return [String] a rubyish Kernel::Format string. 
+      def numeric val
+        ostring = "%"
+        strippedfmt = @numformat.gsub(/\?/, '0').gsub(',','')
+        prefix, decimals, sep, floats, expo, postfix=/(^[^\#0e].?)?([\#0]*)?(\.)?([\#0]*)?(e.?)?(.?[^\#0e]$)?/i.match(strippedfmt).captures
+        ostring.prepend prefix.to_s
+        if !decimals.nil? && decimals.size != 0
+          if (eval decimals) == nil
+            ostring += "##{decimals.size}"
+          elsif (eval decimals) == 0
+            ostring += decimals.size.to_s
+          end
+        else
+          ostring += decimals
+        end
+        ostring += sep.to_s
+        if !floats.nil? && floats.size != 0 # expo!!!
+          ostring += ((floats.size.to_s) +"f")
+        end
+        if sep.nil? && floats.nil? || floats.size == 0
+          ostring += "d"
+        end
+        ostring += (expo.to_s + postfix.to_s) #postfix '+' ?
+        return ostring
+      end
+
+      # Convert excel-style date formats into ruby DateTime strftime format strings
+      # @param [String] val an Excel number format string.
+      # @return [String] a DateTime::strftime format string.
+      def datetime formatcode
+        deminutified = formatcode.downcase.gsub(/(?<hrs>H|h)(?<div>.)m/, '\k<hrs>\k<div>i')
+                         .gsub(/im/, 'ii')
+                         .gsub(/m(?<div>.)(?<secs>s)/, 'i\k<div>\k<secs>')
+                         .gsub(/mi/, 'ii')
+        return deminutified.gsub(/[yMmDdHhSsi]*/, Dtmap)
+      end
+    end
+    
+    # The Numberhelper module implements methods that return the formatted value or the value converted into a Ruby type (DateTime, Numeric, etc)
+    module Numberhelper
+      include Numformats
+      # Get the cell's value and excel format string and return a string, a ruby Numeric or a DateTime object accordingly
+      def to_ru
+        if !@value.numeric? || Numformats::Formatarray[@numformat.to_i][:xl] == nil || Numformats::Formatarray[@numformat.to_i][:xl].downcase == "general"
+          return @value
+        end
+        if Numformats::Formatarray[@numformat.to_i][:cls] == 'numeric' || Numformats::Formatarray[@numformat.to_i][:cls] == 'rational'
+          return eval @value
+        elsif Numformats::Formatarray[@numformat.to_i][:cls] == 'date'
+          return DateTime.new(1899, 12, 30) + (eval @value)
+        else
+          eval @value rescue @value
+        end
+      end
+
+      # Get the cell's value, convert it with to_ru and finally, format it based on the value's type.
+      def to_fmt
+        begin
+          if Numformats::Formatarray[@numformat][:cls] == 'date'
+            self.to_ru.strftime(datetime(Numformats::Formatarray[@numformat][:xl])) rescue @value
+          elsif Numformats::Formatarray[@numformat.to_i][:cls] == 'numeric' || Numformats::Formatarray[@numformat.to_i][:cls] == 'rational'
+            sprintf(numeric(Numformats::Formatarray[@numformat][:xl]), self.to_ru) rescue @value
+          else
+            return @value
+          end
+        end
+      end
+    end
+  end

data/lib/oxcelix/sax/styles.rb

@@ -0,0 +1,49 @@
+require 'ox'
+module Oxcelix
+
+  # Ox based SAX parser which pushes the number formats (taken from the styles.xml file) to an array 
+  # The reference taken from the cell's 's' attribute points to an element of the
+  # style array, which in turn points to a number format (numFmt) that can be
+  # either built-in (@formats) or defined in the styles.xml itself.
+  class Styles < ::Ox::Sax
+    attr_accessor :styleary, :xmlstack, :temparray
+    def initialize
+      @temparray=[]
+      @styleary=[]
+      @xmlstack = []
+      @numform={}
+    end
+
+    def nf key, value
+      @numform[key]=value
+      if @numform.size == 2
+        @temparray << @numform
+        @numform = {}
+      end
+    end
+
+    def numFmtId str
+      if @xmlstack[-2] == :cellXfs
+        @styleary << str
+      elsif @xmlstack[-2] == :numFmts
+        nf :numFmtId, str
+      end
+    end
+
+    def formatCode str
+      nf :formatCode, str
+    end
+    
+    def start_element(name)
+      @xmlstack << name
+    end
+
+    def end_element(name)
+      @xmlstack.pop
+    end
+
+    def attr(name, str)
+      self.send name, str if self.respond_to?(name)
+    end
+  end
+end

data/lib/oxcelix/sax/xlsheet.rb

@@ -62,8 +62,9 @@ module Oxcelix
       end
     end
 
-    # String type cell content is parsed here. String interpolation using the
-    # sharedStrings.xml file is done in the #Sharedstrings class
+    # Cell content is parsed here. For cells containing strings, interpolation using the
+    # sharedStrings.xml file is done in the #Sharedstrings class.
+    # The numformat attribute gets a value here based on the styles variable, to preserve the numeric formatting (thus the type) of values.
     def text(str)
       if @xmlstack.last == :c
         if @cell.type != "shared" && @cell.type != "e" && str.numeric?

data/lib/oxcelix/sheet.rb

@@ -25,5 +25,15 @@ module Oxcelix
         super(i,j[0])
       end
     end
+
+    def to_m(*attrs)
+      m=Matrix.build(self.col(0).length, self.row(0).length){nil}
+      self.each do |x, row, col|
+        if attrs.size == 0 || attrs.nil?
+          m[row, col]=x.value
+        end
+      end
+      return m
+    end
   end
 end

data/lib/oxcelix/workbook.rb

@@ -19,7 +19,10 @@ module Oxcelix
   class Workbook
     include Cellhelper
     include Workbookhelper
+    include Numformats
+    
     attr_accessor :sheets
+
     ##
     # Create a new {Workbook} object.
     #
@@ -31,6 +34,8 @@ module Oxcelix
     # the group of three merged cells <tt>|   a   |</tt> will become <tt>|a|a|a|</tt>
     # * :include (Ary) - an array of sheet names to be included
     # * :exclude (Ary) - an array of sheet names not to be processed
+    # * :values (Symbol) - cell values. This can be: :false, if the whole cell is needed, :excel, if the raw excel values need to be inserted
+    # and :ruby if ruby objects are preferred.
     #
     # The excel file is first getting unzipped, then the workbook.xml file gets
     # processed. This file stores sheet metadata, which will be filtered (by including
@@ -56,10 +61,19 @@ module Oxcelix
       @sheetbase={}
       @sharedstrings=[]
       
-      f=IO.read(@destination+'/xl/workbook.xml')
+      f=IO.read(@destination + '/xl/workbook.xml')
       @a=Ox::load(f)
       
       sheetdata(options); commentsrel; shstrings;
+      
+      styles = Styles.new()
+      File.open(@destination + '/xl/styles.xml', 'r') do |f|
+        Ox.sax_parse(styles, f)
+      end
+
+      styles.temparray.sort_by!{|st| st[:numFmtId].to_i}
+      add_custom_formats styles.temparray
+      styles.styleary.map!{|s| Numformats::Formatarray[s.to_i][:id].to_i}
 
       @sheets.each do |x|
 
@@ -70,6 +84,7 @@ module Oxcelix
         end
         comments = mkcomments(x[:comments])
         @sheet.cellarray.each do |sh|
+          sh.numformat = styles.styleary[sh.style.to_i]
           if sh.type=="s"
             sh.value = @sharedstrings[sh.value.to_i]
           end
@@ -85,7 +100,7 @@ module Oxcelix
         x[:mergedcells] = @sheet.mergedcells
       end
       FileUtils.remove_dir(@destination, true)
-      matrixto(options[:copymerge])
+      matrixto options[:copymerge]
     end
     
     private
@@ -196,14 +211,15 @@ module Oxcelix
     # of each copied cell is changed to reflect the actual Excel coordinate.
     # 
     # The matrix will replace the array of cells in the actual sheet.
-    # @param [Bool ] copymerge 
+    # @param [Bool] copymerge
+    # @yield a value to be put as a cell. e.g: matrixto true, { |x| x = x.value.to_ru } 
     # @return [Matrix] a Matrix object that stores the cell values, and, depending on the copymerge parameter, will copy the merged value
     #  into every merged cell
     def matrixto(copymerge)
       @sheets.each_with_index do |sheet, i|
         m=Sheet.build(sheet[:cells].last.y+1, sheet[:cells].last.x+1) {nil}
         sheet[:cells].each do |c|
-          m[c.y, c.x]=c
+          m[c.y, c.x] = c
         end
         if copymerge==true
           sheet[:mergedcells].each do |mc|

data/lib/oxcelix.rb

@@ -4,12 +4,15 @@ require 'matrix'
 require 'fileutils'
 require 'zip'
 require 'oxcelix/cellhelper'
+require 'oxcelix/numformats'
+require 'oxcelix/nf'
 require 'oxcelix/cell'
 require 'oxcelix/sheet'
 require 'oxcelix/workbook'
 require 'oxcelix/sax/sharedstrings'
 require 'oxcelix/sax/comments'
 require 'oxcelix/sax/xlsheet'
+require 'oxcelix/sax/styles'
 
 class String
   # Returns true if the given String represents a numeric value 

data/oxcelix.gemspec

@@ -3,16 +3,20 @@
 require 'rake'
 Gem::Specification.new do |s|
   s.name	= 'oxcelix'
-  s.version	= '0.2.4'
-  s.date	= '2013-10-10'
+  s.version	= '0.3.0'
+  s.date	= '2013-11-12'
   s.summary	= 'A fast Excel 2007/2010 file parser'
-  s.description	= 'A fast .xlsx file  parser that returns a collection of Matrix objects'
+  s.description	= 'A fast Excel 2007/2010 (.xlsx) file parser that returns a collection of Matrix objects'
   s.authors	= 'Giovanni Biczo'
   s.homepage	= 'http://github.com/gbiczo/oxcelix'
   s.rubyforge_project = 'oxcelix'
 
   s.files	= FileList["LICENSE", "README.rdoc", "README.md",
-		  "lib/*", "lib/oxcelix/*", "lib/oxcelix/sax/*",
+		  "lib/oxcelix.rb", "lib/oxcelix/cellhelper.rb",
+		  "lib/oxcelix/cell.rb", "lib/oxcelix/numformats.rb",
+		  "lib/oxcelix/nf.rb",
+		  "lib/oxcelix/sheet.rb", "lib/oxcelix/workbook.rb",
+		  "lib/oxcelix/sax/*",
 		  "oxcelix.gemspec", "spec/*", ".yardopts", "CHANGES"].to_a
   s.license	= 'MIT'
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oxcelix
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-10 00:00:00.000000000 Z
+date: 2013-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ox
@@ -43,7 +43,8 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.9.9
-description: A fast .xlsx file  parser that returns a collection of Matrix objects
+description: A fast Excel 2007/2010 (.xlsx) file parser that returns a collection
+  of Matrix objects
 email: 
 executables: []
 extensions: []
@@ -52,14 +53,16 @@ files:
 - LICENSE
 - README.rdoc
 - README.md
-- lib/lofaszka.rb
 - lib/oxcelix.rb
+- lib/oxcelix/cellhelper.rb
 - lib/oxcelix/cell.rb
-- lib/oxcelix/workbook.rb
+- lib/oxcelix/numformats.rb
+- lib/oxcelix/nf.rb
 - lib/oxcelix/sheet.rb
-- lib/oxcelix/cellhelper.rb
+- lib/oxcelix/workbook.rb
 - lib/oxcelix/sax/sharedstrings.rb
 - lib/oxcelix/sax/xlsheet.rb
+- lib/oxcelix/sax/styles.rb
 - lib/oxcelix/sax/comments.rb
 - oxcelix.gemspec
 - spec/test.xlsx

data/lib/lofaszka.rb

@@ -1,6 +0,0 @@
-require './oxcelix.rb'
-require 'ruby-debug'
-debugger
-w=Oxcelix::Workbook.new('../Schedules.xlsx', :copymerge=>true)
-#w=Oxcelix::Workbook.new('../Schedules.xlsx')
-puts "kesz"