libis-tools 0.9.42 → 0.9.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ccaa2ba1a94d6b88f3b45135a81b62ea9a0a76ac
-  data.tar.gz: 74d858081b5baf3a1f3181f9a3ff790a70e942e8
+  metadata.gz: 637fd6ebde184f6dcedfb30f78b4b47ec1a7aa35
+  data.tar.gz: 446600a929178ec33509865ae9b069e26b508475
 SHA512:
-  metadata.gz: add083b5399e12b82820d9674e8568a921d8e0a81473c092512c104d28c2ffd1a73b584eb9fb09f4bec359c71f2440ed69dd8a1ad061f9594bb68600e9a7705b
-  data.tar.gz: f65e1a15ef0b042a4ad13c386ce4fcc87f4dcc60db6de59987f621474803d7cd120f91fe0d410288d3446fbbf0d8fec92981a62b0314b19947770847f00d24d8
+  metadata.gz: f1de8197f9df452ccfac937d3973df91fb2c76baed18858bfcbc4314d1a55800a42bd23a56299e65bfba4f10e3aaf963350cff7ad36f4a24497ec25e4bcc48af
+  data.tar.gz: 5d6c903ad244e87b0bd1301b2127deff90da0037a2ac6bb52493c3b8d69af49def55e68c049c1cf9968e9e9d8c8c86a8217f6731314474be22e4329543efc024

data/lib/libis/tools.rb

@@ -7,11 +7,12 @@ module Libis
     autoload :Command, 'libis/tools/command'
     autoload :Config, 'libis/tools/config'
     autoload :ConfigFile, 'libis/tools/config_file'
-    autoload :DCRecord, 'libis/tools/dc_record'
+    autoload :Csv, 'libis/tools/csv'
     autoload :DeepStruct, 'libis/tools/deep_struct'
     autoload :Logger, 'libis/tools/logger'
     autoload :MetsFile, 'libis/tools/mets_file'
     autoload :Parameter, 'libis/tools/parameter'
+    autoload :Spreadsheet, 'libis/tools/spreadsheet'
     autoload :ThreadSafe, 'libis/tools/thread_safe'
     autoload :XmlDocument, 'libis/tools/xml_document'
 

data/lib/libis/tools/extend/roo.rb

@@ -0,0 +1,86 @@
+require 'roo'
+require 'roo-xls'
+require 'roo-google'
+
+module Roo
+  class HeaderRowIncompleteError < Error;
+  end
+  class Base
+
+    def each(options = {})
+      return to_enum(:each, options) unless block_given?
+
+      if options.empty?
+        1.upto(last_row) do |line|
+          yield row(line)
+        end
+      else
+        clean_sheet_if_need(options)
+        search_or_set_header(options)
+        headers = @headers ||
+            Hash[(first_column..last_column).map do |col|
+              [cell(@header_line, col), col]
+            end]
+
+        start_line = @header_line || 1
+        start_line = (@header_line || 0) + 1 if @options[:skip_headers]
+        start_line.upto(last_row) do |line|
+          yield(Hash[headers.map { |k, v| [k, cell(line, v)] }])
+        end
+      end
+    end
+
+    private
+
+    def row_with(query, return_headers = false)
+      line_no = 0
+      each do |row|
+        line_no += 1
+        headers = query.map { |q| row.grep(q)[0] }.compact
+
+        if headers.length == query.length
+          @header_line = line_no
+          return return_headers ? headers : line_no
+        elsif line_no > 100
+          raise Roo::HeaderRowNotFoundError
+        elsif headers.length > 0
+          # partial match
+          @header_line = line_no
+          raise Roo::HeaderRowIncompleteError unless @options[:force_headers]
+          return return_headers ? headers : line_no
+        end
+      end
+      raise Roo::HeaderRowNotFoundError
+    end
+
+    def search_or_set_header(options)
+      if options[:header_search]
+        @headers = nil
+        @header_line = row_with(options[:header_search])
+      elsif [:first_row, true].include?(options[:headers])
+        @headers = Hash[row(first_row).map.with_index{ |x, i| [x, i + first_column] }]
+        @header_line = first_row
+      else
+        set_headers(options)
+      end
+    end
+
+    def set_headers(hash = {})
+      # try to find header row with all values or give an error
+      # then create new hash by indexing strings and keeping integers for header array
+      @headers = row_with(hash.values, true)
+      @headers = Hash[hash.keys.zip(@headers.map { |x| header_index(x) })]
+    rescue Roo::HeaderRowNotFoundError => e
+      if @options[:force_headers]
+        # Finding headers failed. Force the headers in the order they are given, but up to the last column
+        @headers = {}
+        hash.keys.each.with_index { |k, i| @headers[k] = i + first_column if i + first_column <= last_column }
+        @header_line = first_row
+        @header_line -= 1 unless hash.values.any? { |v| row(1).include? v } # partial match
+      else
+        raise e
+      end
+    end
+
+  end
+end

data/lib/libis/tools/spreadsheet.rb

@@ -0,0 +1,170 @@
+require 'libis/tools/extend/roo'
+require 'libis/tools/extend/hash'
+require 'awesome_print'
+
+def PUTS(*args)
+  puts *args
+end
+
+module Libis
+  module Tools
+
+    class Spreadsheet
+
+      # Spreadsheet reader.
+      #
+      # This class supports CSV, Excel 2007-2016, Excel (pre-2007), LibreOffice/OpenOffice Calc and Google spreadsheets
+      # thanks to the Roo (http://github.com/roo-rb/roo) project.
+      #
+      # The first argument is the file name to read. For spreadsheets, append '|' and the sheet name to specify the
+      # sheet to read.
+      #
+      # The second argument is a Hash with options. The options can be:
+      # - required: a list of headers that need to be present. The list can be an Array containing the litteral header
+      #   values expected. Alternatively, a Hash is also allowed with alternative header names as keys and litteral
+      #   names as values. If a :headers keys is present in the Hash with a value of true or :first, whatever is on the
+      #   first row, will be used as header values, ignoring the rest of the Hash. A key of :header_search
+      #   Default is empty array, meaning to use whatever is on the first row as header.
+      # - optional: a list of headers that may be present, but are not required. Similar format as above. Default is
+      #   empty array
+      # - extension: :csv, :xlsx, :xlsm, :ods, :xls, :google to help the library in deciding what format the file is in.
+      #
+      # The following options are only applicable to CSV input files and are ignored otherwise.
+      # - encoding: the encoding of the CSV file. e.g. 'windows-1252:UTF-8' to convert the input from windows code page
+      #   1252 to UTF-8 during file reading
+      # - col_sep: column separator. Default is ',', but can be set to "\t" for TSV files.
+      # - quote_char: character for quoting.
+      #
+      # Resources are created during initialisation and should be freed by calling the #close method.
+      #
+      # @param [String] file_name
+      # @param [Hash] opts
+      def initialize(file_name, opts = {})
+        options = {
+            csv_options: [:encoding, :col_sep, :quote_char].inject({}) do |h, k|
+              h[k] = opts.delete(k) if opts[k]
+              h
+            end.merge(
+                encoding: 'UTF-8',
+                col_sep: ',',
+                quote_char: '"',
+            ),
+            skip_headers: true,
+            force_headers: true,
+        }.merge(opts)
+
+        required_headers = options.delete(:required) || []
+        optional_headers = options.delete(:optional) || []
+
+        file, sheet = file_name.split('|')
+        @ss = ::Roo::Spreadsheet.open(file, options)
+        @ss.default_sheet = sheet if sheet
+
+        check_headers(required_headers, optional_headers)
+
+      end
+
+      # Iterate over sheet content.
+      #
+      # The options Hash can contain the following keys:
+      # - :sheet - overwrites default sheet name
+      # - :required - Array or Hash of required headers
+      # - :optional - Array or Hash of optional headers
+      #
+      # Each iteration, a Hash will be passed with the key names as specified in the header options and the
+      # corresponding cell values.
+      #
+      # @param [Hash] options
+      def each(options = {}, &block)
+        @ss.default_sheet = options[:sheet] if options[:sheet]
+        @ss.each(check_headers(options[:required], options[:optional]), &block)
+      end
+
+      def parse(options = {})
+        @ss.default_sheet = options[:sheet] if options[:sheet]
+        @ss.parse(check_headers(options[:required], options[:optional]))
+      end
+
+      def shift
+        return nil unless @current_row < @ss.last_row
+        @current_row += 1
+        Hash[@ss.row(@current_row).map.with_index { |v, i| [headers[i], v] }]
+      end
+
+      # Open and iterate over sheet content.
+      #
+      # @param @see #initialize
+      def self.foreach(file_name, opts = {}, &block)
+        Libis::Tools::Spreadsheet.new(file_name, opts).each(&block)
+      end
+
+      def headers
+        (@ss.headers || {}).keys + @extra_headers
+      end
+
+      private
+
+      def check_headers(required_headers, optional_headers)
+        return @header_options unless required_headers || optional_headers
+        header_options = {}
+        required_headers ||= []
+        optional_headers ||= []
+        unless required_headers.is_a?(Hash) || required_headers.is_a?(Array)
+          raise RuntimeError, 'Required headers should be either a Hash or an Array.'
+        end
+        unless optional_headers.is_a?(Hash) || optional_headers.is_a?(Array)
+          raise RuntimeError, 'Optional headers should be either a Hash or an Array.'
+        end
+        if required_headers.empty?
+          if optional_headers.empty?
+            header_options[:headers] = :first_row
+          else
+            header_options[:header_search] =
+                (optional_headers.is_a?(Hash) ? optional_headers.values : optional_headers)
+          end
+        else
+          header_options =
+              required_headers.is_a?(Hash) ? required_headers : Hash[required_headers.map { |x| [x] * 2 }]
+          header_options.merge!(
+              optional_headers.is_a?(Hash) ? optional_headers : Hash[optional_headers.map { |x| [x] * 2 }]
+          )
+        end
+
+        required_headers = required_headers.values if required_headers.is_a?(Hash)
+
+        @ss.each(header_options) { break }
+        @current_row = @ss.header_line
+
+        # checks
+        PUTS 'required_headers:', required_headers.ai
+        PUTS 'header_line: ', @ss.header_line
+        PUTS 'header_row:', @ss.row([@ss.header_line, 1].max).ai
+        found_headers = required_headers & @ss.row([@current_row, 1].max)
+        if found_headers.empty?
+          # No headers found - check if there are enough columns to satisfy the required headers
+          if required_headers.size > (@ss.last_column - @ss.first_column) + 1
+            raise RuntimeError, 'Sheet does not contain enough columns.'
+          end
+        elsif found_headers.size < required_headers.size
+          # Some, but not all headers found
+          raise RuntimeError, "Headers not found: #{required_headers - found_headers}."
+        else
+          # All required headers found
+        end
+
+        PUTS 'sheet headers: ', @ss.headers.ai
+        PUTS 'header_line: ', @ss.header_line.ai
+        PUTS 'header_options: ', header_options.ai
+        PUTS 'header row:', @ss.row(@ss.header_line).ai
+        @extra_headers = (required_headers.empty? && optional_headers.empty?) ? [] :
+            @ss.row(@ss.header_line).keep_if { |x| x && !header_options.values.include?(x) }
+        PUTS '@extra_headers:', @extra_headers.ai
+        PUTS 'headers:', headers.ai
+
+        @header_options = header_options.merge(Hash[@extra_headers.map { |v| [v] * 2 }])
+      end
+
+    end
+
+  end
+end

data/lib/libis/tools/version.rb

@@ -1,5 +1,5 @@
 module Libis
   module Tools
-    VERSION = '0.9.42'
+    VERSION = '0.9.43'
   end
 end

data/libis-tools.gemspec

@@ -44,4 +44,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'logging', '~> 2.0'
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
   spec.add_runtime_dependency 'yard', '~> 0.8'
+  spec.add_runtime_dependency 'roo', '~> 2.5'
+  spec.add_runtime_dependency 'roo-xls', '~> 1.0'
+  spec.add_runtime_dependency 'roo-google', '~> 1.0'
 end

data/spec/metadata/scope_mapper_spec.rb

@@ -21,7 +21,6 @@ describe 'ScopeMapper' do
     converted_dc = input_dc.to_dc
     expect(converted_dc).to be_a Libis::Tools::Metadata::DublinCoreRecord
 
-    expect(converted_dc.root).to be_equivalent_to output_dc.root
     converted_dc.root.elements.each_with_index do |element, i|
       expect(element).to be_equivalent_to(output_dc.root.elements[i])
     end

data/spec/spreadsheet_spec.rb

@@ -0,0 +1,1335 @@
+# encoding: utf-8
+require_relative 'spec_helper'
+require 'rspec/matchers'
+require 'libis/tools/spreadsheet'
+
+describe 'Libis::Tools::Spreadsheet' do
+
+  let(:path) { File.absolute_path('data', File.dirname(__FILE__)) }
+  let(:ss) {
+    Libis::Tools::Spreadsheet.new(
+        File.join(path, file_name),
+        required: required_headers,
+        optional: optional_headers
+    )
+  }
+
+  let(:optional_headers) { [] }
+
+  context 'CSV file' do
+    context 'with headers' do
+      let(:file_name) { 'test-headers.csv' }
+
+      context 'well-formed' do
+
+        let(:required_headers) { %w'FirstName LastName' }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'FirstName LastName address'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to eq 'mystreet 1, myplace'
+          expect(row['phone']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 1
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to eq 'mystreet 1, myplace'
+          expect(row['phone']).to be_nil
+        end
+
+      end
+
+      context 'not specified' do
+
+        let(:required_headers) { [] }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          expect(ss.headers).to eq %w'FirstName LastName address'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to eq 'mystreet 1, myplace'
+          expect(row['phone']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 1
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to eq 'mystreet 1, myplace'
+          expect(row['phone']).to be_nil
+        end
+
+      end
+
+      context 'not well-formed' do
+
+        let(:required_headers) { %w'FirstName LastName address phone'}
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Headers not found: ["phone"].')
+        end
+      end
+
+    end
+
+    context 'without headers' do
+      let(:file_name) { 'test-noheaders.csv' }
+
+      context 'well-formed and strict' do
+        let(:required_headers) { %w'FirstName LastName' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'FirstName LastName'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to be_nil
+          expect(row['phone']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 1
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to be_nil
+          expect(row['phone']).to be_nil
+        end
+
+      end
+
+      context 'well-formed with optional headers' do
+        let(:required_headers) { %w'FirstName LastName' }
+        let(:optional_headers) { %w'address' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains required and optional headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'FirstName LastName address'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to eq 'mystreet 1, myplace'
+          expect(row['phone']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 1
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to eq 'mystreet 1, myplace'
+          expect(row['phone']).to be_nil
+        end
+
+      end
+
+      context 'missing optional headers' do
+
+        let(:required_headers) { %w'FirstName LastName address' }
+        let(:optional_headers) { %w'phone' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).not_to include header
+          end
+          expect(ss.headers).to eq %w'FirstName LastName address'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to eq 'mystreet 1, myplace'
+          expect(row['phone']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 1
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['FirstName']).to eq 'John'
+          expect(row['LastName']).to eq 'Smith'
+          expect(row['address']).to eq 'mystreet 1, myplace'
+          expect(row['phone']).to be_nil
+        end
+
+      end
+
+      context 'missing required header' do
+        let(:required_headers) { %w'FirstName LastName address phone'}
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Sheet does not contain enough columns.')
+        end
+
+      end
+
+    end
+
+  end
+
+  context 'XLSX file' do
+    # let(:ss) {
+    #   Libis::Tools::Spreadsheet.new(
+    #       File.join(path, file_name),
+    #       required: required_headers,
+    #       optional: optional_headers,
+    #       extension: :xlsx
+    #   )
+    # }
+
+    context 'with headers' do
+      let(:file_name) { 'test.xlsx|Expenses' }
+
+      context 'well-formed' do
+
+        let(:required_headers) { %w'Date Amount' }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'not specified' do
+
+        let(:required_headers) { [] }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'not well-formed' do
+
+        let(:required_headers) { %w'Date dummy1 Amount dummy2'}
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Headers not found: ["dummy1", "dummy2"].')
+        end
+      end
+
+    end
+
+    context 'without headers' do
+      let(:file_name) { 'test.xlsx|ExpensesNoHeaders' }
+
+      context 'well-formed and strict' do
+        let(:required_headers) { %w'Date Amount' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'well-formed with optional headers' do
+        let(:required_headers) { %w'Date Amount' }
+        let(:optional_headers) { %w'Code' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains required and optional headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'missing optional headers' do
+
+        let(:required_headers) { %w'Date Amount Code Remark' }
+        let(:optional_headers) { %w'dummy' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).not_to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'missing required header' do
+        let(:required_headers) { %w'Date Amount Code Remark dummy' }
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Sheet does not contain enough columns.')
+        end
+
+      end
+
+    end
+
+    context 'blank rows with headers' do
+      let(:file_name) { 'test.xlsx|ExpensesBlankRows' }
+
+      context 'well-formed' do
+
+        let(:required_headers) { %w'Date Amount' }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'not specified' do
+
+        let(:required_headers) { [] }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'not well-formed' do
+
+        let(:required_headers) { %w'Date dummy1 Amount dummy2'}
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Headers not found: ["dummy1", "dummy2"].')
+        end
+      end
+
+    end
+
+    context 'blank rows without headers' do
+      let(:file_name) { 'test.xlsx|ExpensesBlankRowsNoHeaders' }
+
+      context 'well-formed and strict' do
+        let(:required_headers) { %w'Date Amount' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'well-formed with optional headers' do
+        let(:required_headers) { %w'Date Amount' }
+        let(:optional_headers) { %w'Code' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains required and optional headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'missing optional headers' do
+
+        let(:required_headers) { %w'Date Amount Code Remark' }
+        let(:optional_headers) { %w'dummy' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).not_to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'missing required header' do
+        let(:required_headers) { %w'Date Amount Code Remark dummy' }
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Sheet does not contain enough columns.')
+        end
+
+      end
+
+    end
+
+    context 'blank columns with headers' do
+      let(:file_name) { 'test.xlsx|ExpensesBlankColumns' }
+
+      context 'well-formed' do
+
+        let(:required_headers) { %w'Date Amount' }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          puts row
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'not specified' do
+
+        let(:required_headers) { [] }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          puts row
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'not well-formed' do
+
+        let(:required_headers) { %w'Date dummy1 Amount dummy2'}
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Headers not found: ["dummy1", "dummy2"].')
+        end
+      end
+
+    end
+
+    context 'blank columns without headers' do
+      let(:file_name) { 'test.xlsx|ExpensesBlankColumnsNoHeaders' }
+
+      context 'well-formed and strict' do
+        let(:required_headers) { %w'Date Amount' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'well-formed with optional headers' do
+        let(:required_headers) { %w'Date Amount' }
+        let(:optional_headers) { %w'Code' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains required and optional headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'missing optional headers' do
+
+        let(:required_headers) { %w'Date Amount Code Remark' }
+        let(:optional_headers) { %w'dummy' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).not_to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'missing required header' do
+        let(:required_headers) { %w'Date Amount Code Remark dummy' }
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Sheet does not contain enough columns.')
+        end
+
+      end
+
+    end
+
+    context 'blank row and columns with headers' do
+      let(:file_name) { 'test.xlsx|ExpensesBlankRowsAndColumns' }
+
+      context 'well-formed' do
+
+        let(:required_headers) { %w'Date Amount' }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          puts row
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'not specified' do
+
+        let(:required_headers) { [] }
+
+        it 'opens correctly' do
+          expect{ ss }.not_to raise_error
+        end
+
+        it 'contains expected headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          puts row
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'not well-formed' do
+
+        let(:required_headers) { %w'Date dummy1 Amount dummy2'}
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Headers not found: ["dummy1", "dummy2"].')
+        end
+      end
+
+    end
+
+    context 'blank row and columns without headers' do
+      let(:file_name) { 'test.xlsx|ExpensesBlankRowsAndColumnsNoH' }
+
+      context 'well-formed and strict' do
+        let(:required_headers) { %w'Date Amount' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to be_nil
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'well-formed with optional headers' do
+        let(:required_headers) { %w'Date Amount' }
+        let(:optional_headers) { %w'Code' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains required and optional headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to be_nil
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'missing optional headers' do
+
+        let(:required_headers) { %w'Date Amount Code Remark' }
+        let(:optional_headers) { %w'dummy' }
+
+        it 'opens correctly' do
+          expect { ss }.not_to raise_error
+        end
+
+        it 'contains only required headers' do
+          required_headers.each do |header|
+            expect(ss.headers).to include header
+          end
+          optional_headers.each do |header|
+            expect(ss.headers).not_to include header
+          end
+          expect(ss.headers).to eq %w'Date Amount Code Remark'
+        end
+
+        it '#shift returns Hash object' do
+          row = ss.shift
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016, 05, 10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+        end
+
+        it '#parse returns Array of Hash objects' do
+          rows = ss.parse
+          expect(rows).to be_a Array
+          expect(rows.size).to eq 17
+          row = rows[0]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,5,10)
+          expect(row['Amount']).to eq 1270.0
+          expect(row['Code']).to eq 1
+          expect(row['Remark']).to eq 'a'
+          expect(row['dummy']).to be_nil
+          row = rows[13]
+          expect(row).to be_a Hash
+          expect(row['Date']).to eq Date.new(2016,7,1)
+          expect(row['Amount']).to eq 3705.0
+          expect(row['Code']).to eq 3
+          expect(row['Remark']).to eq 'b'
+          expect(row['dummy']).to be_nil
+        end
+
+      end
+
+      context 'missing required header' do
+        let(:required_headers) { %w'Date Amount Code Remark dummy' }
+
+        it 'throws error when opened' do
+          expect { ss }.to raise_error(RuntimeError, 'Sheet does not contain enough columns.')
+        end
+
+      end
+
+    end
+
+  end
+
+end