rxl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f566fd08f3ea5b2d4db76a07fc545b2752d7da3
+  data.tar.gz: 8f85cbc1c2a444b39c5a2fb9b12552b7a24f9ee6
+SHA512:
+  metadata.gz: bf0e88cdebaf333f4fc36fe9e06bd812c19560937e1b0417a433ca29c01ecd6b91471d2c2ac6f5c596b90b25a7b1f9e04b54a2ec238d0a4fecc9f21ea85fb3cd
+  data.tar.gz: 2a81b4685affb3c6725cf96b10834161fb8071ddeb3bbcfd68b6e39067006099967f33ef635a48c7a38cc336ff1a3763ecabe9473d4a30ae976f11f122408b61

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea
+**/sandbox.*
+/.analysis

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require 'spec_helper'

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at ian.mcwilliams@f3mmedia.co.uk. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rxl.gemspec
+gemspec
+
+gem 'awesome_print'
+gem 'mitrush'
+gem 'rubocop'
+gem 'rubyXL'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Ian McWilliams
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,179 @@
+# Rxl
+
+The purpose of the RXL gem is to provide a ruby/Excel interface that provides the following features:
+
+1. Specification using Excel key indices (A1, B5 etc)
+2. Avoiding multi-level class management by utilising the ruby hash
+3. Simplified handling with the aim of doing less, better - eg no setting of properties for full rows/columns in Excel files
+
+The mechanics of the conversion between xlsx and ruby hash have been implemented using the RubyXL gem:
+
+https://github.com/weshatheleopard/rubyXL
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rxl'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rxl
+
+## Usage
+
+With some exceptions (due mainly to the vagaries of Excel) a file can be read in and the resulting hash passed to the write method to save a duplicate of the original.
+
+### Read from file
+
+To read a file to hash simply pass the filepath:
+
+```ruby
+Rxl.read_file('path/to/file.xlxs')
+```
+
+The format of the excel read hash has the following skeleton:
+
+```ruby
+{
+    "Sheet1" => {
+      row_count: 1,
+      column_count: 1,
+      rows: {},
+      columns: {},
+      cells: {
+          'A1' => {
+              value: 'abc',
+              format: 'text'
+          }
+      }
+    }
+}
+```
+
+Bear in mind the limitations of reading cell formats. Everything is read as a string other than:
+* cells formatted as dates are converted to a DateTime object with the time portion set to midnight
+* cells formatted as times are converted to a DateTime object with the date portion set to 31/12/1899 - unless the cell has a date prefix in which case this is carried in (this will be read as a date format as per below parsing rules)
+* numbers (including floats and percentages) where the cell format is number or percentage are read in as integers - trailing zeroes are cropped from floats in this case and percentages are converted to numeric format (eg 100% = 1)
+* formulas are not read from cells with date and time formats
+
+Within these limitations the cell hash's :format holds the best analysis of the original cell format but as there's no way to extract all of the format information directly from the sheet some information may need to be refurbished as required after import via Rxl.
+
+Further to the above, these rules are applied by Rxl when parsing cells:
+* strings are given text format
+* DateTime objects are given date format except where the date is 31/12/1899 in which case they are given time format
+
+
+
+
+### Read tables from file
+
+To read a file where the data is in table format - headers and values, no totals or otherwise extra content:
+
+```ruby
+Rxl.read_file_as_tables('path/to/file.xlsx')
+```
+
+The format of the excel table read hash has the following skeleton:
+
+```ruby
+{
+    "Sheet1" => [
+      {
+          header_a: value,
+          header_b: value
+      },
+      {
+          header_a: value,
+          header_b: value
+      },
+    ]
+}
+```
+
+### Write to file
+
+To write a file pass the filename and hash:
+
+```ruby
+Rxl.write_file('path/to/save.xlsx', hash_workbook)
+```
+
+The format of the excel hash_workbook must contain at least the following skeleton:
+
+```ruby
+{
+    "Sheet1" => {
+      cells: {
+          'A1' => {
+              value: 'abc',
+              format: 'text'
+          }
+      }
+    }
+}
+```
+
+#### Cell specification
+
+All cells are written with the format set to general except those with a number format specified
+
+Specify the number format according to https://support.office.com/en-us/article/number-format-codes-5026bbd6-04bc-48cd-bf33-80f18b4eae68?ui=en-US&rs=en-US&ad=US
+
+Examples:
+
+| value        | number format | resulting cell format | resulting cell value |
+|--------------|---------------|-----------------------|----------------------|
+| 0            | 0             | number                | 0                    |
+| 0.49         | 0             | number                | 0                    |
+| 0.5          | 0             | number                | 1                    |
+| 0            | 0.00          | number                | 0.00                 |
+| 0            | 0%            | percentage            | 0%                   |
+| 1            | 0%            | percentage            | 100%                 |
+| '01/01/2000' | 'dd/mm/yyyy'  | date                  | 01/01/2000           |
+
+#### Write Validation
+
+The following rules are validated for write_file:
+
+* The hash_workbook must be a hash (NB if empty a blank file will be created with a single sheet called "Sheet1")
+* The hash_workbook keys must be strings
+* The hash_workbook values (hash_worksheet) must be hashes
+
+
+* The hash_worksheet keys must be symbols
+* The following keys are allowed for hash_worksheet: :cells, :rows, :columns
+* The hash_worksheet values must be arrays - those arrays must contain only hashes
+
+
+* The arrays' child hash keys must be strings of valid Excel cell id format (or stringified number for a row, capitalised alpha for a column)
+* The arrays' child hash values must be hashes (hash_cell)
+* The hash_cell keys must conform the the cell specification as below
+
+* If a formula is provided the value must be nil or an empty string
+* If a number format is provided the value must be consistent with it
+
+
+TODO: Add further detail
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rxl. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rxl"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/cell.rb

@@ -0,0 +1,130 @@
+require 'rubyXL'
+
+module Cell
+
+  ##############################################
+  ###     GET HASH CELL FROM RUBYXL CELL     ###
+  ##############################################
+
+  def self.rubyxl_cell_to_hash_cell(rubyxl_cell = nil)
+    rubyxl_cell_value = rubyxl_cell.nil? ? RubyXL::Cell.new.value : rubyxl_cell.value
+    {
+        value: rubyxl_cell_value,
+        format: hash_cell_format(rubyxl_cell_value),
+        formula: rubyxl_cell_formula(rubyxl_cell),
+        h_align: rubyxl_cell_horizontal_alignment(rubyxl_cell),
+        v_align: rubyxl_cell_vertical_alignment(rubyxl_cell)
+    }
+  end
+
+  def self.rubyxl_cell_formula(rubyxl_cell)
+    return nil if rubyxl_cell.nil? || rubyxl_cell.formula.nil? || rubyxl_cell.formula.expression.empty?
+    rubyxl_cell.formula.expression
+  end
+
+  def self.rubyxl_cell_horizontal_alignment(rubyxl_cell)
+    return nil if rubyxl_cell.nil? || rubyxl_cell.horizontal_alignment.nil?
+    rubyxl_cell.horizontal_alignment.to_sym
+  end
+
+  def self.rubyxl_cell_vertical_alignment(rubyxl_cell)
+    return :bottom if rubyxl_cell.nil? || rubyxl_cell.vertical_alignment.nil?
+    rubyxl_cell.vertical_alignment.to_sym
+  end
+
+  def self.hash_cell_format(rubyxl_cell_value)
+    format = {
+        nilclass: :general,
+        string: :text,
+        fixnum: :number,
+        float: :number,
+        datetime: :date,
+    }[rubyxl_cell_value.class.to_s.downcase.to_sym]
+    format == :date && rubyxl_cell_value.strftime('%Y%m%d') == '18991231' ? :time : format
+  end
+
+
+  ##############################################
+  ###     GET RUBYXL CELL FROM HASH CELL     ###
+  ##############################################
+
+  def self.hash_cell_to_rubyxl_cell(combined_hash_cell, rubyxl_worksheet, row_index, column_index)
+    merge_row_index, merge_column_index = RubyXL::Reference.ref2ind(combined_hash_cell[:merge])
+
+    rubyxl_worksheet.merge_cells(row_index, column_index, merge_column_index, merge_row_index) if combined_hash_cell[:merge]
+    rubyxl_worksheet.change_column_width(column_index, combined_hash_cell[:width])  if combined_hash_cell[:width]
+
+    rubyxl_worksheet[row_index][column_index].change_font_name(combined_hash_cell[:font_style]) if combined_hash_cell[:font_style]
+    rubyxl_worksheet[row_index][column_index].change_font_size(combined_hash_cell[:font_size]) if combined_hash_cell[:font_size]
+    rubyxl_worksheet[row_index][column_index].change_fill(combined_hash_cell[:fill]) if combined_hash_cell[:fill]
+    rubyxl_worksheet[row_index][column_index].change_horizontal_alignment(combined_hash_cell[:align]) if combined_hash_cell[:align]
+    rubyxl_worksheet[row_index][column_index].change_font_bold(combined_hash_cell[:bold]) if combined_hash_cell[:bold]
+
+    if combined_hash_cell[:border_all]
+      rubyxl_worksheet[row_index][column_index].change_border('top' , combined_hash_cell[:border_all])
+      rubyxl_worksheet[row_index][column_index].change_border('bottom' , combined_hash_cell[:border_all])
+      rubyxl_worksheet[row_index][column_index].change_border('left' , combined_hash_cell[:border_all])
+      rubyxl_worksheet[row_index][column_index].change_border('right' , combined_hash_cell[:border_all])
+    end
+  end
+
+  def self.add_rubyxl_cells(combined_hash_cell, rubyxl_worksheet, row_index, column_index)
+    if combined_hash_cell[:formula]
+      rubyxl_worksheet.add_cell(row_index, column_index, '', combined_hash_cell[:formula]).set_number_format combined_hash_cell[:dp_2]
+    else
+      rubyxl_worksheet.add_cell(row_index, column_index, combined_hash_cell[:value])
+    end
+  end
+
+  def self.get_combined_hash_cell(hash_worksheet, hash_cell_key, hash_cell)
+    # first get data from the matching column if it's specified
+    column_keys = hash_worksheet[:columns].keys.select { |key| hash_cell_key =~ /^#{key}\d+$/ }
+    column_keys.empty? ? hash_column = {} : hash_column = hash_worksheet[:columns][column_keys[0]]
+    combined_hash_cell = hash_column.merge(hash_cell)
+    # then get data from the matching row if it's specified
+    row_keys = hash_worksheet[:rows].keys.select { |key| hash_cell_key =~ /^\D+#{key}$/ }
+    row_keys.empty? ? hash_row = {} : hash_row = hash_worksheet[:rows][row_keys[0]]
+    combined_hash_cell = hash_row.merge(combined_hash_cell)
+    hash_worksheet[:worksheet].merge(combined_hash_cell)
+  end
+
+
+  ##################################
+  ###     VALIDATE HASH CELL     ###
+  ##################################
+
+  def self.validate_hash_cell(hash_cell_key, hash_cell, trace)
+    unless validate_cell_key(hash_cell_key)
+      raise(%[invalid cell key at path #{trace}, must be String and in Excel format (eg "A1")])
+    end
+    unless hash_cell.is_a?(Hash)
+      raise("cell value at path #{trace + [hash_cell_key]} must be a Hash")
+    end
+    unless hash_cell.keys.reject { |key| key.is_a?(Symbol) }.empty?
+      raise("cell key at path #{trace + [hash_cell_key]} must be a Symbol")
+    end
+    unless hash_cell.keys.delete_if { |key| valid_cell_keys.include?(key) }.empty?
+      valid_cell_keys_string = ":#{valid_cell_keys.join(', :')}"
+      raise(%(invalid cell hash key at path #{trace + [hash_cell_key]}, valid keys are: [#{valid_cell_keys_string}]))
+    end
+    # TODO: add validation for hash_cell specification
+  end
+
+  def self.validate_cell_key(cell_key)
+    return false unless cell_key.is_a?(String)
+    return false unless cell_key[/^[A-Z]{1,3}[0-9]{1,7}$/]
+    cell_index = RubyXL::Reference.ref2ind(cell_key)
+    return false unless cell_index[0].between?(0, 1_048_575)
+    return false unless cell_index[0].between?(0, 16383)
+    true
+  end
+
+  def self.valid_cell_keys
+    %i[
+      value
+      number
+      formula
+    ]
+  end
+
+end

data/lib/cells.rb

@@ -0,0 +1,19 @@
+module Cells
+
+  def self.rubyxl_to_hash(rubyxl_rows)
+    hash_cells = {}
+    rubyxl_rows.each do |rubyxl_row_hash|
+      rubyxl_row = rubyxl_row_hash[:rubyxl_row]
+      rubyxl_row_index = rubyxl_row_hash[:rubyxl_row_index]
+      rubyxl_row_cells = rubyxl_row&.cells
+      unless rubyxl_row_cells.nil?
+        rubyxl_row_cells.each_with_index do |rubyxl_cell, rubyxl_column_index|
+          hash_cell_key = RubyXL::Reference.ind2ref(rubyxl_row_index, rubyxl_column_index)
+          hash_cells[hash_cell_key] = Cell.rubyxl_cell_to_hash_cell(rubyxl_cell)
+        end
+      end
+    end
+    hash_cells
+  end
+
+end

data/lib/rxl.rb

@@ -0,0 +1,26 @@
+require 'rxl/version'
+require 'rubyXL'
+require_relative 'workbook'
+
+module Rxl
+
+  def self.write_file(filepath, hash_workbook)
+    begin
+      rubyxl_workbook = Workbook.hash_workbook_to_rubyxl_workbook(hash_workbook)
+    rescue => e
+      return e
+    end
+    rubyxl_workbook.write(filepath)
+  end
+
+  def self.read_file(filepath)
+    rubyxl_workbook = RubyXL::Parser.parse(filepath)
+    Workbook.rubyxl_to_hash(rubyxl_workbook)
+  end
+
+  def self.read_file_as_tables(filepath)
+    hash_workbook = read_file(filepath)
+    Workbook.hash_workbook_to_hash_tables(hash_workbook)
+  end
+
+end

data/lib/rxl/version.rb

@@ -0,0 +1,3 @@
+module Rxl
+  VERSION = "0.1.0"
+end

data/lib/workbook.rb

@@ -0,0 +1,43 @@
+require_relative 'worksheet'
+
+module Workbook
+
+  def self.rubyxl_to_hash(rubyxl_workbook)
+    hash_workbook = {}
+    rubyxl_workbook.each do |rubyxl_worksheet|
+      hash_workbook[rubyxl_worksheet.sheet_name] = Worksheet.rubyxl_to_hash(rubyxl_worksheet)
+    end
+    hash_workbook
+  end
+
+  def self.hash_workbook_to_rubyxl_workbook(hash_workbook)
+    validate_hash_workbook(hash_workbook)
+    rubyxl_workbook = RubyXL::Workbook.new
+    first_worksheet = true
+    hash_workbook.each do |hash_key, hash_value|
+      if first_worksheet
+        rubyxl_workbook.worksheets[0].sheet_name = hash_key
+        first_worksheet = false
+      else
+        rubyxl_workbook.add_worksheet(hash_key)
+      end
+      Worksheet.set_hash_worksheet_defaults(hash_value)
+      Worksheet.hash_worksheet_to_rubyxl_worksheet(hash_value, rubyxl_workbook[hash_key])
+    end
+    rubyxl_workbook
+  end
+
+  def self.hash_workbook_to_hash_tables(hash_workbook)
+    hash_workbook.keys.each_with_object({}) do |key, hash_tables|
+      hash_tables[key] = Worksheet.hash_worksheet_to_hash_table(hash_workbook[key])
+    end
+  end
+
+  def self.validate_hash_workbook(hash_workbook)
+    raise('workbook must be a Hash') unless hash_workbook.is_a?(Hash)
+    hash_workbook.each do |hash_worksheet_name, hash_worksheet|
+      Worksheet.validate_hash_worksheet(hash_worksheet_name, hash_worksheet)
+    end
+  end
+
+end

data/lib/worksheet.rb

@@ -0,0 +1,96 @@
+require 'rubyXL'
+require 'mitrush'
+require_relative 'cell'
+require_relative 'cells'
+
+module Worksheet
+
+  ########################################################
+  ###     GET HASH WORKSHEET FROM RUBYXL WORKSHEET     ###
+  ########################################################
+
+  def self.rubyxl_to_hash(rubyxl_worksheet)
+    rubyxl_rows = rubyxl_worksheet.each_with_index.map do |rubyxl_row, rubyxl_row_index|
+      { rubyxl_row: rubyxl_row, rubyxl_row_index: rubyxl_row_index }
+    end
+    hash_worksheet = Cells.rubyxl_to_hash(rubyxl_rows)
+    process_sheet_to_populated_block(hash_worksheet)
+    Mitrush.delete_keys(hash_worksheet, %i[row_count column_count])
+    hash_worksheet
+  end
+
+
+  ########################################################
+  ###     GET RUBYXL WORKSHEET FROM HASH WORKSHEET     ###
+  ########################################################
+
+  def self.hash_worksheet_to_rubyxl_worksheet(hash_worksheet, rubyxl_worksheet)
+    process_sheet_to_populated_block(hash_worksheet)
+    (hash_worksheet[:cells] || {}).sort.each do |hash_cell_key, hash_cell|
+      combined_hash_cell = Cell.get_combined_hash_cell(hash_worksheet, hash_cell_key, hash_cell)
+      row_index, column_index = RubyXL::Reference.ref2ind(hash_cell_key)
+      Cell.add_rubyxl_cells(combined_hash_cell, rubyxl_worksheet, row_index, column_index)
+      Cell.hash_cell_to_rubyxl_cell(combined_hash_cell, rubyxl_worksheet, row_index, column_index)
+    end
+  end
+
+
+  ##############################
+  ###     SHARED METHODS     ###
+  ##############################
+
+  def self.process_sheet_to_populated_block(hash_worksheet)
+    extent = hash_worksheet_extents(hash_worksheet)
+    extent[:row_count].times do |row_index|
+      extent[:column_count].times do |column_index|
+        cell_key = RubyXL::Reference.ind2ref(row_index, column_index)
+        hash_worksheet[cell_key] = Cell.rubyxl_cell_to_hash_cell unless hash_worksheet[cell_key]
+      end
+    end
+  end
+
+  def self.hash_worksheet_extents(hash_worksheet)
+    extents = { row_count: 0, column_count: 0 }
+    (hash_worksheet || {}).keys.each do |hash_cell_key|
+      row_index, column_index = RubyXL::Reference.ref2ind(hash_cell_key)
+      extents[:row_count] = row_index + 1 if row_index >= extents[:row_count]
+      extents[:column_count] = column_index + 1 if column_index >= extents[:column_count]
+    end
+    extents
+  end
+
+
+  ####################################
+  ###     OTHER PUBLIC METHODS     ###
+  ####################################
+
+  def self.set_hash_worksheet_defaults(hash_worksheet)
+    %i[worksheet columns rows].each do |key|
+      hash_worksheet[key] = {} unless hash_worksheet.has_key?(key)
+    end
+  end
+
+  def self.hash_worksheet_to_hash_table(raw_hash)
+    cells = raw_hash[:cells]
+    columns = cells.keys.map { |key| key[/\D+/] }.uniq
+    cells.keys.map { |key| key[/\d+/] }.uniq[1..-1].map do |row_number|
+      columns.each_with_object({}) do |column_letter, this_hash|
+        this_hash[cells["#{column_letter}1"][:value]] = cells["#{column_letter}#{row_number}"][:value]
+      end
+    end
+  end
+
+  def self.validate_hash_worksheet(hash_worksheet_name, hash_worksheet)
+    unless hash_worksheet_name.is_a?(String)
+      raise('worksheet name must be a String')
+    end
+    raise('worksheet name must not be an empty String') if hash_worksheet_name.empty?
+    unless hash_worksheet.is_a?(Hash)
+      raise(%(worksheet value at path ["#{hash_worksheet_name}"] must be a Hash))
+    end
+    hash_worksheet.each do |hash_cell_key, hash_cell|
+      Cell.validate_hash_cell(hash_cell_key, hash_cell, [hash_worksheet_name])
+    end
+  end
+
+end

data/rubocop.yml

@@ -0,0 +1,2 @@
+AllCops:
+  TargetRubyVersion: 2.3

data/rxl.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rxl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rxl"
+  spec.version       = Rxl::VERSION
+  spec.authors       = ["Ian McWilliams"]
+  spec.email         = ["ian.mcwilliams@f3mmedia.co.uk"]
+
+  spec.summary       = "A ruby spreadsheet interface"
+  spec.description   = <<~DESC
+    Implements functionality written with Excel users in mind for straight reading and writing of sheets.
+    Row and column scope values are written to only the cells used; cells are specified by their Excel (A1) ID.
+  DESC
+  spec.homepage      = "https://github.com/f3mmedia/rxl"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: rxl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ian McWilliams
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |
+  Implements functionality written with Excel users in mind for straight reading and writing of sheets.
+  Row and column scope values are written to only the cells used; cells are specified by their Excel (A1) ID.
+email:
+- ian.mcwilliams@f3mmedia.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/cell.rb
+- lib/cells.rb
+- lib/rxl.rb
+- lib/rxl/version.rb
+- lib/workbook.rb
+- lib/worksheet.rb
+- rubocop.yml
+- rxl.gemspec
+homepage: https://github.com/f3mmedia/rxl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.3
+signing_key: 
+specification_version: 4
+summary: A ruby spreadsheet interface
+test_files: []