hash_math 0.0.1 → 1.0.0.pre.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 634c0b1692a46994e23fc56cc31346a128182d19da45adaa8913d23898d91b5b
-  data.tar.gz: 7cf7a06c956965072b2dcb0dfe4e8bbccd962a44380c60289d9e9b377d7c8f6a
+  metadata.gz: 298a64b54732cd96f7145ecba9b7e3a8e1424e4513609c75269cff8de9ebd039
+  data.tar.gz: 1fa6896667948c39b05169e232fd916d20a35ac6415e068195560a2552c2051d
 SHA512:
-  metadata.gz: e5dfeff921d808b1f77d7e303a076ca5a6d3f50760fb7b9296332c443950679858c3498ba6e2629fbe13cdc5fbc5de5cc5c4a74d491299c434d14b529ef46a29
-  data.tar.gz: bc92933f546e34bdb244215e715a690db94cf3d85ff156e05c5383406ab831616162567b6862be89ad6e555d77a64504988f760e2b197825013d21e7e8966351
+  metadata.gz: 7867d22fc5bd88a24adb3031706302621e5e3f2c8aae353cfe83e323fd8b7ba0d25afb86f1403c9e796899b90df6789a823a0139d833ed5ac87d899edef11d44
+  data.tar.gz: cc6703151537b76d44bd322e11a4b698e0829de8c250707611475b9959b7a30260c9aee328bedfea956db6142f339e57d5ca790294006378d4d65bd4f293b58f

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 1.0.0-alpha (September 16th, 2019)
+
+Added initial implementation of:
+
+* HashMath::Matrix
+* HashMath::Record
+* HashMath::Table
+
 # 0.0.1 (September 16th, 2019)
 
 Published initial shell.  Library has no functionality yet.

data/README.md

@@ -2,4 +2,238 @@
 
 [![Gem Version](https://badge.fury.io/rb/hash_math.svg)](https://badge.fury.io/rb/hash_math) [![Build Status](https://travis-ci.org/bluemarblepayroll/hash_math.svg?branch=master)](https://travis-ci.org/bluemarblepayroll/hash_math) [![Maintainability](https://api.codeclimate.com/v1/badges/9f9a504b3f5df199a253/maintainability)](https://codeclimate.com/github/bluemarblepayroll/hash_math/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/9f9a504b3f5df199a253/test_coverage)](https://codeclimate.com/github/bluemarblepayroll/hash_math/test_coverage) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Under Construction.
+Ruby's Hash data structure is ubiquitous and highly flexible.  This library contains common Hash patterns widely used within our code-base:
+
+* Matrix: build a hash up then expand into hash products
+* Record: define a list of keys and base value to use as a blueprint for hashes
+* Table: key-value pair two-dimensional array of hash builder
+
+See examples for more information on each data structure.
+
+## Installation
+
+To install through Rubygems:
+
+````bash
+gem install install hash_math
+````
+
+You can also add this to your Gemfile:
+
+````bash
+bundle add hash_math
+````
+
+## Examples
+
+### Matrix: The Hash Combination Calculator
+
+HashMath::Matrix is a key-value builder that outputs all the different hash combinations.
+
+Say we have this type of matrix:
+
+````ruby
+{
+  a: [1,2,3],
+  b: [4,5,6],
+  c: [7,8,9]
+}
+````
+
+We could code this as:
+
+````ruby
+matrix = HashMath::Matrix.new
+matrix.add_each(:a, [1,2,3])
+matrix.add_each(:b, [4,5,6])
+matrix.add_each(:c, [7,8,9])
+````
+
+Note: you can also call `Matrix#add` to only add a single value instead of add_each.
+
+and get the combinations by calling to_a:
+
+````ruby
+combinations = matrix.to_a
+````
+
+which would yield the following hashes:
+
+````ruby
+[
+  { a: 1, b: 4, c: 7 },
+  { a: 1, b: 4, c: 8 },
+  { a: 1, b: 4, c: 9 },
+  { a: 1, b: 5, c: 7 },
+  { a: 1, b: 5, c: 8 },
+  { a: 1, b: 5, c: 9 },
+  { a: 1, b: 6, c: 7 },
+  { a: 1, b: 6, c: 8 },
+  { a: 1, b: 6, c: 9 },
+
+  { a: 2, b: 4, c: 7 },
+  { a: 2, b: 4, c: 8 },
+  { a: 2, b: 4, c: 9 },
+  { a: 2, b: 5, c: 7 },
+  { a: 2, b: 5, c: 8 },
+  { a: 2, b: 5, c: 9 },
+  { a: 2, b: 6, c: 7 },
+  { a: 2, b: 6, c: 8 },
+  { a: 2, b: 6, c: 9 },
+
+  { a: 3, b: 4, c: 7 },
+  { a: 3, b: 4, c: 8 },
+  { a: 3, b: 4, c: 9 },
+  { a: 3, b: 5, c: 7 },
+  { a: 3, b: 5, c: 8 },
+  { a: 3, b: 5, c: 9 },
+  { a: 3, b: 6, c: 7 },
+  { a: 3, b: 6, c: 8 },
+  { a: 3, b: 6, c: 9 },
+]
+````
+
+Notes:
+
+* Matrix implements Ruby's Enumerable, which means you have the ability to iterate over each hash combination like you would any other Enumerable object.
+* Values can be arrays and it still works.  For example, `#add` (singular form) will honor the array data type: `matrix.add(:a, [1,2,3])` is **not** the same as: `matrix.add_each(:a, [1,2,3])` but it **is** the same as: `matrix.add(:a, [[1,2,3]])`
+* Keys are type-sensitive and work just like Hash keys work.
+
+### Record: The Hash Prototype
+
+HashMath::Record generates a prototype hash and ensures all derived hashes conform to its shape.
+
+Say we have a person hash, for example:
+
+````ruby
+{
+  id: 1,
+  name: 'Matt',
+  location: 'Chicago'
+}
+````
+
+we could create a record modeling this:
+
+````ruby
+record = HashMath::Record.new(%i[id name location], 'UNKNOWN')
+````
+
+Then, we could shape all other hashes using it to ensure each key is populated.  If a key is not populated, the base value will be used ('UNKNOWN' in our case.)  For example:
+
+````ruby
+records = [
+  record.make(id: 1, name: 'Matt', location: 'Chicago', dob: nil),
+  record.make(id: 2, age: 24),
+  record.make(id: 3, location: 'Los Angeles')
+]
+````
+
+Note: The keys `dob` and `age` appeared in the input but will be ignored as they do not conform to the Record.  You could make this strict and raise an error by calling `#make!` instead of `#make`.
+
+our `records` would now equate to:
+
+````ruby
+[
+  { id: 1, name: 'Matt', location: 'Chicago' },
+  { id: 2, name: 'UNKNOWN', location: 'UNKNOWN' },
+  { id: 3, name: 'UNKNOWN', location: 'Los Angeles' },
+]
+````
+
+Notes:
+
+* keys are type-sensitive and works just like Hash keys work.
+
+### Table: The Double Hash (Hash of Hashes)
+
+HashMath::Table builds on top of HashMath::Record.  It constructs a table data-structure using a key-value pair builder method: `#add(row_id, field_id, key, value)`.  It ultimately outputs an array of Row objects where each Row object has a row_id and fields (field_id => value) hash.  The value proposition here is you can iterate over a key-value pair and construct each row any way you wish.
+
+Building on our Record example above:
+
+````ruby
+record = HashMath::Record.new(%i[name location], 'UNKNOWN')
+
+table = HashMath::Table.new(record)
+                       .add(1, :name, 'Matt')
+                       .add(1, :location, 'Chicago')
+                       .add(2, :name, 'Nick')
+                       .add(3, :location, 'Los Angeles')
+                       .add(2, :name 'Nicholas') # notice the secondary call to "2, :name"
+
+rows = table.to_a
+````
+
+which would set our variable `rows` to:
+
+````ruby
+[
+  HashMath::Row.new(1, { name: 'Matt', location: 'Chicago' }),
+  HashMath::Row.new(2, { name: 'Nicholas', location: 'UNKNOWN' }),
+  HashMath::Row.new(3, { name: 'UNKNOWN', location: 'Los Angeles' })
+]
+````
+
+Notes:
+
+* `#add` will throw a KeyOutOfBoundsError if the key is not found.
+* key is type-sensitive and works just like Hash keys work.
+
+## Contributing
+
+### Development Environment Configuration
+
+Basic steps to take to get this repository compiling:
+
+1. Install [Ruby](https://www.ruby-lang.org/en/documentation/installation/) (check hash_math.gemspec for versions supported)
+2. Install bundler (gem install bundler)
+3. Clone the repository (git clone git@github.com:bluemarblepayroll/hash_math.git)
+4. Navigate to the root folder (cd hash_math)
+5. Install dependencies (bundle)
+
+### Running Tests
+
+To execute the test suite and code-coverage tool, run:
+
+````bash
+bundle exec rspec spec --format documentation
+````
+
+Alternatively, you can have Guard watch for changes:
+
+````bash
+bundle exec guard
+````
+
+Also, do not forget to run Rubocop:
+
+````bash
+bundle exec rubocop
+````
+
+or run all three in one command:
+
+````bash
+bundle exec rake
+````
+
+### Publishing
+
+Note: ensure you have proper authorization before trying to publish new versions.
+
+After code changes have successfully gone through the Pull Request review process then the following steps should be followed for publishing new versions:
+
+1. Merge Pull Request into master
+2. Update `lib/hash_math/version.rb` using [semantic versioning](https://semver.org/)
+3. Install dependencies: `bundle`
+4. Update `CHANGELOG.md` with release notes
+5. Commit & push master to remote and ensure CI builds master successfully
+6. 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).
+
+## Code of Conduct
+
+Everyone interacting in this codebase, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/bluemarblepayroll/hash_math/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+This project is MIT Licensed.

data/lib/hash_math.rb

@@ -7,6 +7,11 @@
 # LICENSE file in the root directory of this source tree.
 #
 
+require_relative 'hash_math/matrix'
+require_relative 'hash_math/record'
+require_relative 'hash_math/table'
+
 # Top-level namespace
 module HashMath
+  class KeyOutOfBoundsError < StandardError; end
 end

data/lib/hash_math/matrix.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'matrix/key_value_pair'
+
+module HashMath
+  # A Matrix allows you to build up a hash of key and values, then it will generate the
+  # product of all values.
+  class Matrix
+    extend Forwardable
+    include Enumerable
+
+    def_delegators :pair_products, :each
+
+    def initialize
+      @pairs_by_key = {}
+
+      freeze
+    end
+
+    def add_each(key, vals)
+      tap { kvp(key).add_each(vals) }
+    end
+
+    def add(key, val)
+      tap { kvp(key).add(val) }
+    end
+
+    private
+
+    attr_reader :pairs_by_key
+
+    def kvp(key)
+      pairs_by_key[key] ||= KeyValuePair.new(key)
+    end
+
+    def pair_products
+      pair_groups = pairs_by_key.values.map(&:pairs)
+
+      products = pair_groups.inject(pair_groups.shift) { |memo, f| memo.product(f) }
+                            &.map { |f| f.is_a?(KeyValuePair::Pair) ? [f] : f.flatten } || []
+
+      products.map { |pairs| recombine(pairs) }
+    end
+
+    def recombine(pairs)
+      pairs.each_with_object({}) { |p, memo| memo[p.key] = p.value }
+    end
+  end
+end

data/lib/hash_math/matrix/key_value_pair.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module HashMath
+  class Matrix
+    # A hash-like structure that allows you to gradually build up keys.
+    class KeyValuePair
+      Pair = Struct.new(:key, :value)
+
+      attr_reader :key, :value
+
+      def initialize(key)
+        @key    = key
+        @value  = Set.new
+
+        freeze
+      end
+
+      def add_each(vals)
+        tap { vals.each { |val| add(val) } }
+      end
+
+      def add(val)
+        tap { value << val }
+      end
+
+      def pairs
+        value.map { |value| Pair.new(key, value) }
+      end
+    end
+  end
+end

data/lib/hash_math/record.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module HashMath
+  # A Record serves as a prototype for a Hash.  It will allow the output of hashes
+  # conforming to a strict (#make!) or non-strict (#make) shape.
+  class Record
+    extend Forwardable
+
+    def_delegators :prototype, :key?, :keys
+
+    def initialize(keys = [], base_value = nil)
+      @prototype = keys.map { |key| [key, base_value] }.to_h
+
+      freeze
+    end
+
+    def make!(hash = {})
+      make(hash, true)
+    end
+
+    def make(hash = {}, bound = false)
+      hash.each_with_object(shallow_copy_prototype) do |(key, value), memo|
+        next unless assert_key_in_bounds(key, bound)
+
+        memo[key] = value
+      end
+    end
+
+    private
+
+    attr_reader :prototype
+
+    # raise error if key is not in key set and bound is true
+    # return true if key is in key set and bound is false
+    # return false if key is not in key set and bound is false
+    def assert_key_in_bounds(key, bound)
+      raise KeyOutOfBoundsError, "[#{key}] for: #{keys}" if not_key?(key) && bound
+
+      key?(key)
+    end
+
+    def not_key?(key)
+      !key?(key)
+    end
+
+    def shallow_copy_prototype
+      {}.merge(prototype)
+    end
+  end
+end

data/lib/hash_math/table.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module HashMath
+  # The main data structure for a virtual table that can be treated as a key-value builder.
+  # Basically, it is a hash with a default 'prototype' assigned to it, which serves as the
+  # base record.  Then, #add is called over and over passing in row_id, field_id, and value,
+  # which gives it enough information to pinpoint where to insert the data (memory-wise.)
+  # Imagine a two-dimensional table where X is the field_id axis and row is the Y axis.
+  # Since it is essentially backed by a hash, the row_id and field_id can be anything that
+  # implements #hash, #eql? and #== properly.
+  class Table
+    extend Forwardable
+    include Enumerable
+
+    Row = Struct.new(:row_id, :fields)
+
+    attr_reader :lookup, :record
+
+    def_delegators :record, :keys, :key?
+
+    def initialize(record)
+      raise ArgumentError, 'record is required' unless record
+
+      @lookup = {}
+      @record = record
+
+      freeze
+    end
+
+    def add(row_id, field_id, value)
+      raise KeyOutOfBoundsError, "field_id: #{field_id} not allowed." unless key?(field_id)
+
+      tap { set(row_id, field_id, value) }
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+
+      lookup.map do |row_id, fields|
+        Row.new(row_id, record.make!(fields)).tap { |row| yield(row) }
+      end
+    end
+
+    private
+
+    def row(row_id)
+      lookup[row_id] ||= {}
+    end
+
+    def set(row_id, field_id, value)
+      row(row_id)[field_id] = value
+    end
+  end
+end

data/lib/hash_math/version.rb

@@ -8,5 +8,5 @@
 #
 
 module HashMath
-  VERSION = '0.0.1'
+  VERSION = '1.0.0-alpha'
 end

data/spec/hash_math/matrix_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe HashMath::Matrix do
+  let(:examples) do
+    {
+      {} => [],
+      { a: :b } => [
+        { a: :b }
+      ],
+      { a: 'a1', b: 'b1', c: 'c1' } => [
+        { a: 'a1', b: 'b1', c: 'c1' }
+      ],
+      { a: %w[a1 a2], b: 'b1', c: 'c1' } => [
+        { a: 'a1', b: 'b1', c: 'c1' },
+        { a: 'a2', b: 'b1', c: 'c1' }
+      ],
+      { a: %w[a1 a2], b: %w[b1 b2], c: 'c1' } => [
+        { a: 'a1', b: 'b1', c: 'c1' },
+        { a: 'a1', b: 'b2', c: 'c1' },
+        { a: 'a2', b: 'b1', c: 'c1' },
+        { a: 'a2', b: 'b2', c: 'c1' }
+      ],
+      { a: %w[a1 a2], b: %w[b1 b2], c: %w[c1 c2] } => [
+        { a: 'a1', b: 'b1', c: 'c1' },
+        { a: 'a1', b: 'b1', c: 'c2' },
+        { a: 'a1', b: 'b2', c: 'c1' },
+        { a: 'a1', b: 'b2', c: 'c2' },
+
+        { a: 'a2', b: 'b1', c: 'c1' },
+        { a: 'a2', b: 'b1', c: 'c2' },
+        { a: 'a2', b: 'b2', c: 'c1' },
+        { a: 'a2', b: 'b2', c: 'c2' }
+      ]
+    }
+  end
+
+  specify '#produce generates correct matrix-expanded hashes' do
+    examples.each_pair do |hash, expanded_hashes|
+      subject = described_class.new
+
+      hash.each_pair do |k, v|
+        v.is_a?(Array) ? subject.add_each(k, v) : subject.add(k, v)
+      end
+
+      expect(subject.to_a).to eq(expanded_hashes)
+    end
+  end
+end

data/spec/hash_math/record_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe HashMath::Record do
+  let(:base_value) { '*' }
+
+  let(:examples) do
+    {
+      { a: :b } => { a: :b, c: base_value, 'a' => base_value, 'c' => base_value },
+      { c: :d } => { a: base_value, c: :d, 'a' => base_value, 'c' => base_value },
+      { 'a' => :b } => { a: base_value, c: base_value, 'a' => :b, 'c' => base_value },
+      { 'c' => :d } => { a: base_value, c: base_value, 'a' => base_value, 'c' => :d }
+    }
+  end
+
+  subject do
+    described_class.new(examples.keys.map(&:keys).flatten, base_value)
+  end
+
+  describe '#initialize' do
+    it 'derives prototype' do
+      expected = {
+        a: base_value,
+        c: base_value,
+        'a' => base_value,
+        'c' => base_value
+      }
+
+      expect(subject.make).to eq(expected)
+    end
+  end
+
+  describe '#make' do
+    it 'generates correct hashes' do
+      examples.each_pair do |hash, normalized_hash|
+        expect(subject.make(hash)).to eq(normalized_hash)
+      end
+    end
+  end
+end

data/spec/hash_math/table_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe HashMath::Table do
+  RowId   = Struct.new(:id1, :id2)
+  FieldId = Struct.new(:name1, :name2)
+
+  let(:base_value) { 'NOT_ADDED' }
+
+  context 'with simple row and field id types' do
+    let(:prototype) do
+      HashMath::Record.new(%i[name age location], base_value)
+    end
+
+    subject { described_class.new(prototype) }
+
+    it 'works for integer row_id and symbol field_id' do
+      subject.add(1, :name, 'matt')
+      subject.add(2, :age, 990)
+      subject.add(3, :location, 'earth')
+
+      rows = subject.to_a
+
+      expected = [
+        described_class::Row.new(1, name: 'matt', age: base_value, location: base_value),
+        described_class::Row.new(2, name: base_value, age: 990, location: base_value),
+        described_class::Row.new(3, name: base_value, age: base_value, location: 'earth')
+      ]
+
+      expect(rows).to eq(expected)
+    end
+
+    it 'raises KeyOutOfBoundsError if field_id is not defined in the record' do
+      expect { subject.add(4, 'name', '') }.to          raise_error(HashMath::KeyOutOfBoundsError)
+      expect { subject.add(4, :something_else, '') }.to raise_error(HashMath::KeyOutOfBoundsError)
+    end
+  end
+
+  context 'with more complex object subclass row and field id types' do
+    let(:prototype) do
+      HashMath::Record.new(
+        [
+          FieldId.new(:name, :first),
+          FieldId.new(:address, :st1)
+        ],
+        base_value
+      )
+    end
+
+    subject { described_class.new(prototype) }
+
+    it 'works for more complex row_id and field_id' do
+      subject.add(RowId.new(1, 2), FieldId.new(:name, :first), 'matt')
+      subject.add(RowId.new(3, 4), FieldId.new(:name, :first), 'nick')
+      subject.add(RowId.new(5, 6), FieldId.new(:name, :first), 'sam')
+
+      subject.add(RowId.new(1, 2), FieldId.new(:address, :st1), 'mag mile')
+      subject.add(RowId.new(3, 4), FieldId.new(:address, :st1), 'saturn ln.')
+
+      rows = subject.to_a
+
+      expected = [
+        described_class::Row.new(
+          RowId.new(1, 2),
+          FieldId.new(:name, :first) => 'matt',
+          FieldId.new(:address, :st1) => 'mag mile'
+        ),
+        described_class::Row.new(
+          RowId.new(3, 4),
+          FieldId.new(:name, :first) => 'nick',
+          FieldId.new(:address, :st1) => 'saturn ln.'
+        ),
+        described_class::Row.new(
+          RowId.new(5, 6),
+          FieldId.new(:name, :first) => 'sam',
+          FieldId.new(:address, :st1) => base_value
+        )
+      ]
+
+      expect(rows).to eq(expected)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_math
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0.pre.alpha
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-16 00:00:00.000000000 Z
+date: 2019-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard-rspec
@@ -132,7 +132,14 @@ files:
 - bin/console
 - hash_math.gemspec
 - lib/hash_math.rb
+- lib/hash_math/matrix.rb
+- lib/hash_math/matrix/key_value_pair.rb
+- lib/hash_math/record.rb
+- lib/hash_math/table.rb
 - lib/hash_math/version.rb
+- spec/hash_math/matrix_spec.rb
+- spec/hash_math/record_spec.rb
+- spec/hash_math/table_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/bluemarblepayroll/hash_math
 licenses:
@@ -149,13 +156,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.3.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Hash-based data structures and algorithms
 test_files:
+- spec/hash_math/matrix_spec.rb
+- spec/hash_math/record_spec.rb
+- spec/hash_math/table_spec.rb
 - spec/spec_helper.rb