Added mapping cell ids with header column name (#93)

* Added mapping cell ids with header column name

* Added readme description

* Exclude masOS files in .gitignore

* Added tests and small refactoring

Author: Dmitry Alekseichik

.gitignore

@@ -15,3 +15,6 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+
+# Mac finder artifacts
+.DS_Store

README.md

@@ -100,6 +100,14 @@ remote_url = 'http://dev-builds.libreoffice.org/tmp/test.xlsx'
 Creek::Book.new remote_url, remote: true
 ```
 
+## Mapping cells with header names
+By default, Creek will map cell names with letter and number(A1, B3 and etc). To be able to get cell values by header column name use ***with_headers*** (can be used only with ***#simple_rows*** method!!!) during creation *(Note: header column is first string of sheet)*
+
+```ruby
+creek = Creek::Book.new file.path, with_headers: true
+```
+
+
 ## Contributing
 
 Contributions are welcomed. You can fork a repository, add your code changes to the forked branch, ensure all existing unit tests pass, create new unit tests which cover your new changes and finally create a pull request.

lib/creek.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'creek/version'
 require 'creek/book'
 require 'creek/styles/constants'

lib/creek/book.rb

@@ -4,12 +4,11 @@
 require 'open-uri'
 
 module Creek
-
   class Creek::Book
-
     attr_reader :files,
                 :sheets,
-                :shared_strings
+                :shared_strings,
+                :with_headers
 
     DATE_1900 = Date.new(1899, 12, 30).freeze
     DATE_1904 = Date.new(1904, 1, 1).freeze
@@ -23,6 +22,7 @@ def initialize path, options = {}
       path = download_file(path) if options[:remote]
       @files = Zip::File.open(path)
       @shared_strings = SharedStrings.new(self)
+      @with_headers = options.fetch(:with_headers, false)
     end
 
     def sheets
@@ -41,7 +41,17 @@ def sheets
       rels = Nokogiri::XML::Document.parse(rels_doc).css("Relationship")
       @sheets = xml.css(cssPrefix+'sheet').map do |sheet|
         sheetfile = rels.find { |el| sheet.attr("r:id") == el.attr("Id") }.attr("Target")
-        Sheet.new(self, sheet.attr("name"), sheet.attr("sheetid"),  sheet.attr("state"), sheet.attr("visible"), sheet.attr("r:id"), sheetfile)
+        sheet = Sheet.new(
+          self,
+          sheet.attr("name"),
+          sheet.attr("sheetid"),
+          sheet.attr("state"),
+          sheet.attr("visible"),
+          sheet.attr("r:id"),
+          sheetfile
+        )
+        sheet.with_headers = with_headers
+        sheet
       end
     end
 

lib/creek/sheet.rb

@@ -1,20 +1,25 @@
+# frozen_string_literal: true
+
 require 'zip/filesystem'
 require 'nokogiri'
 
 module Creek
   class Creek::Sheet
     include Creek::Utils
 
+    HEADERS_ROW_NUMBER = '1'
+
+    attr_accessor :with_headers
     attr_reader :book,
                 :name,
                 :sheetid,
                 :state,
                 :visible,
                 :rid,
-                :index
-
+                :index,
+                :headers
 
-    def initialize book, name, sheetid, state, visible, rid, sheetfile
+    def initialize(book, name, sheetid, state, visible, rid, sheetfile)
       @book = book
       @name = name
       @sheetid = sheetid
@@ -46,7 +51,6 @@ def images_at(cell)
       @drawing.images_at(cell) if @images_present
     end
 
-
     ##
     # Provides an Enumerator that returns a hash representing each row.
     # The key of the hash is the column ID and the value is the value of the cell.
@@ -89,35 +93,37 @@ def rows_generator include_meta_data=false, use_simple_rows_format=false
         closer = Nokogiri::XML::Reader::TYPE_END_ELEMENT
         Enumerator.new do |y|
           row, cells, cell = nil, {}, nil
-          cell_type  = nil
+          cell_type = nil
           cell_style_idx = nil
           @book.files.file.open(path) do |xml|
             Nokogiri::XML::Reader.from_io(xml).each do |node|
-              if (node.name.eql? 'row') and (node.node_type.eql? opener)
+              if node.name == 'row' && node.node_type == opener
                 row = node.attributes
-                row['cells'] = Hash.new
-                cells = Hash.new
+                row['cells'] = {}
+                cells = {}
                 y << (include_meta_data ? row : cells) if node.self_closing?
-              elsif (node.name.eql? 'row') and (node.node_type.eql? closer)
+              elsif node.name == 'row' && node.node_type == closer
                 processed_cells = fill_in_empty_cells(cells, row['r'], cell, use_simple_rows_format)
+                @headers = processed_cells if row['r'] == HEADERS_ROW_NUMBER
 
                 if @images_present
                   processed_cells.each do |cell_name, cell_value|
                     next unless cell_value.nil?
+
                     processed_cells[cell_name] = images_at(cell_name)
                   end
                 end
 
                 row['cells'] = processed_cells
                 y << (include_meta_data ? row : processed_cells)
-              elsif (node.name.eql? 'c') and (node.node_type.eql? opener)
+              elsif node.name == 'c' && node.node_type == opener
                 cell_type      = node.attributes['t']
                 cell_style_idx = node.attributes['s']
                 cell           = node.attributes['r']
-              elsif (['v', 't'].include? node.name) and (node.node_type.eql? opener)
+              elsif %w[v t].include?(node.name) && node.node_type == opener
                 unless cell.nil?
                   node.read
-                  cells[(use_simple_rows_format ? cell.tr("0-9", "") : cell)] = convert(node.value, cell_type, cell_style_idx)
+                  cells[cell] = convert(node.value, cell_type, cell_style_idx)
                 end
               end
             end
@@ -142,15 +148,13 @@ def converter_options
     # The unzipped XML file does not contain any node for empty cells.
     # Empty cells are being padded in using this function
     def fill_in_empty_cells(cells, row_number, last_col, use_simple_rows_format)
-      new_cells = Hash.new
+      new_cells = {}
+      return new_cells if cells.empty?
 
-      unless cells.empty?
-        last_col = last_col.gsub(row_number, '')
-
-        ("A"..last_col).to_a.each do |column|
-          id = use_simple_rows_format ? "#{column}" : "#{column}#{row_number}"
-          new_cells[id] = cells[id]
-        end
+      last_col = last_col.gsub(row_number, '')
+      ('A'..last_col).to_a.each do |column|
+        id = cell_id(column, use_simple_rows_format, row_number)
+        new_cells[id] = cells["#{column}#{row_number}"]
       end
 
       new_cells
@@ -172,5 +176,11 @@ def extract_drawing_filepath
       sheet_rels_filepath = expand_to_rels_path(sheet_filepath)
       parse_xml(sheet_rels_filepath).css("Relationship[@Id='#{drawing_rid}']").first.attributes['Target'].value
     end
+
+    def cell_id(column, use_simple_rows_format, row_number = '')
+      return "#{column}#{row_number}" unless use_simple_rows_format
+
+      with_headers && headers ? headers[column] : column
+    end
   end
 end

spec/fixtures/sample-with-headers.xlsx

@@ -1,26 +1,26 @@
+# frozen_string_literal: true
+
 require './spec/spec_helper'
 
 describe 'sheet' do
   let(:book_with_images) { Creek::Book.new('spec/fixtures/sample-with-images.xlsx') }
-  let(:book_no_images) { Creek::Book.new('spec/fixtures/sample.xlsx') }
   let(:sheetfile) { 'worksheets/sheet1.xml' }
   let(:sheet_with_images) { Creek::Sheet.new(book_with_images, 'Sheet 1', 1, '', '', '1', sheetfile) }
-  let(:sheet_no_images) { Creek::Sheet.new(book_no_images, 'Sheet 1', 1, '', '', '1', sheetfile) }
 
   def load_cell(rows, cell_name)
-    cell = rows.find { |row| !row[cell_name].nil? }
+    cell = rows.find { |row| row[cell_name] }
     cell[cell_name] if cell
   end
 
   context 'escaped ampersand' do
     let(:book_escaped) { Creek::Book.new('spec/fixtures/escaped.xlsx') }
     it 'does NOT escape ampersand' do
-      expect(book_escaped.sheets[0].rows.to_enum.map(&:values)).to eq([["abc", "def"], ["ghi", "j&k"]])
+      expect(book_escaped.sheets[0].rows.to_enum.map(&:values)).to eq([%w[abc def], %w[ghi j&k]])
     end
 
     let(:book_escaped2) { Creek::Book.new('spec/fixtures/escaped2.xlsx') }
     it 'does escape ampersand' do
-      expect(book_escaped2.sheets[0].rows.to_enum.map(&:values)).to eq([["abc", "def"], ["ghi", "j&k"]])
+      expect(book_escaped2.sheets[0].rows.to_enum.map(&:values)).to eq([%w[abc def], %w[ghi j&k]])
     end
   end
 
@@ -66,6 +66,9 @@ def load_cell(rows, cell_name)
     end
 
     context 'with excel without images' do
+      let(:book_no_images) { Creek::Book.new('spec/fixtures/sample.xlsx') }
+      let(:sheet_no_images) { Creek::Sheet.new(book_no_images, 'Sheet 1', 1, '', '', '1', sheetfile) }
+
       it 'does not break on with_images' do
         rows = sheet_no_images.with_images.rows.map { |r| r }
         expect(load_cell(rows, 'A10')).to eq(0.15)
@@ -94,4 +97,28 @@ def load_cell(rows, cell_name)
       expect(image).to eq(nil)
     end
   end
+
+  describe '#simple_rows' do
+    let(:book_with_headers) { Creek::Book.new('spec/fixtures/sample-with-headers.xlsx') }
+    let(:sheet) { Creek::Sheet.new(book_with_headers, 'Sheet 1', 1, '', '', '1', sheetfile) }
+
+    subject { sheet.simple_rows.to_a[1] }
+
+    it 'returns values by letters' do
+      expect(subject['A']).to eq 'value1'
+      expect(subject['B']).to eq 'value2'
+    end
+
+    context 'when enable with_headers property' do
+      before { sheet.with_headers = true }
+
+      subject { sheet.simple_rows.to_a[1] }
+
+      it 'returns values by headers name' do
+        expect(subject['HeaderA']).to eq 'value1'
+        expect(subject['HeaderB']).to eq 'value2'
+        expect(subject['HeaderC']).to eq 'value3'
+      end
+    end
+  end
 end