hash_math 0.0.1 → 1.2.0

data/lib/hash_math/unpivot/pivot.rb

@@ -0,0 +1,47 @@
+# 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 Unpivot
+    # A single pivot definition consists of which columns to coalesce and to where.
+    class Pivot
+      acts_as_hashable
+
+      attr_reader :coalesce_key,
+                  :coalesce_key_value,
+                  :keys
+
+      # keys is an array of keys to include in the un-pivoting.
+      # coalesce_key is the new key to use.
+      # coalesce_key_value is the new key to use for its corresponding values.
+      def initialize(keys:, coalesce_key:, coalesce_key_value:)
+        @keys               = Array(keys)
+        @coalesce_key       = coalesce_key
+        @coalesce_key_value = coalesce_key_value
+
+        freeze
+      end
+
+      # The most rudimentary portion of the Unpivoting algorithm, this method works on
+      # just one pivot and returns the extrapolated, un-pivoted rows.
+      # Takes two hashes as input:
+      # the first will serve as the prototype for each returned hash
+      # the second will be one to use for value extraction.
+      # Returns an array of hashes.
+      def expand(base_hash, value_hash) # :nodoc:
+        keys.map do |key|
+          base_hash.merge(
+            coalesce_key => key,
+            coalesce_key_value => value_hash[key]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hash_math/unpivot/pivot_set.rb

@@ -0,0 +1,54 @@
+# 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 'pivot'
+
+module HashMath
+  class Unpivot
+    # A set of pivots for an Unpivot class to perform.
+    class PivotSet
+      acts_as_hashable
+      extend Forwardable
+
+      attr_reader :pivots
+
+      def_delegators :pivots, :any?
+
+      def initialize(pivots: [])
+        @pivots = Pivot.array(pivots)
+      end
+
+      # Adds another Pivot configuration object to this objects list of pivots.
+      # Returns self.
+      def add(pivot)
+        tap { pivots << Pivot.make(pivot) }
+      end
+
+      # An aggregation of Pivot#expand.  This method will iterate over all pivots
+      # and expand them all out.
+      def expand(hash) # :nodoc:
+        base_hash = make_base_hash(hash)
+
+        pivots.map { |pivot| pivot.expand(base_hash, hash) }
+      end
+
+      private
+
+      def make_base_hash(hash)
+        keys_to_remove = key_set
+
+        hash.reject { |k, _v| keys_to_remove.include?(k) }
+      end
+
+      def key_set
+        pivots.flat_map(&:keys).to_set
+      end
+    end
+  end
+end

data/lib/hash_math/version.rb

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

data/spec/hash_math/mapper/mapping_spec.rb

@@ -0,0 +1,74 @@
+# 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::Mapper::Mapping do
+  let(:active)           { { id: 1, name: 'active' } }
+  let(:inactive)         { { id: 2, name: 'inactive' } }
+  let(:patient_statuses) { [active, inactive] }
+
+  let(:mapping) do
+    {
+      lookup: {
+        name: :patient_statuses,
+        by: :name
+      },
+      set: :patient_status_id,
+      value: :patient_status,
+      with: :id
+    }
+  end
+
+  subject do
+    described_class.make(mapping).add_each(patient_statuses)
+  end
+
+  let(:omitted) do
+    { patient_id: 1 }
+  end
+
+  let(:filled) do
+    { patient_id: 2, patient_status: 'active' }
+  end
+
+  let(:mismatched) do
+    { patient_id: 2, patient_status: 'doesnt_exist' }
+  end
+
+  context 'when keys are missing' do
+    it 'returns hash with nil values' do
+      expected = omitted.merge(patient_status_id: nil)
+
+      subject.map!(omitted)
+
+      expect(omitted).to eq(expected)
+    end
+  end
+
+  context 'when keys are present' do
+    it 'returns hash with values' do
+      expected = filled.merge(patient_status_id: 1)
+
+      subject.map!(filled)
+
+      expect(filled).to eq(expected)
+    end
+  end
+
+  context 'when keys are present but values are missing' do
+    it 'returns hash with nil values' do
+      expected = mismatched.merge(patient_status_id: nil)
+
+      subject.map!(mismatched)
+
+      expect(mismatched).to eq(expected)
+    end
+  end
+end

data/spec/hash_math/mapper_spec.rb

@@ -0,0 +1,139 @@
+# 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::Mapper do
+  let(:active)   { { id: 1, name: 'active' } }
+  let(:inactive) { { id: 2, name: 'inactive' } }
+  let(:archived) { { id: 3, name: 'archived' } }
+
+  let(:single)   { { id: 1, code: 'single' } }
+  let(:married)  { { id: 2, code: 'married' } }
+  let(:divorced) { { id: 3, code: 'divorced' } }
+
+  let(:patient_statuses) { [active, inactive, archived] }
+  let(:marital_statuses) { [single, married, divorced] }
+
+  subject do
+    described_class
+      .new(mappings)
+      .add_each(:patient_statuses, patient_statuses)
+      .add_each(:marital_statuses, marital_statuses)
+  end
+
+  let(:mappings) do
+    [
+      {
+        lookup: {
+          name: :patient_statuses,
+          by: :name
+        },
+        set: :patient_status_id,
+        value: :patient_status,
+        with: :id
+      },
+      {
+        lookup: {
+          name: :marital_statuses,
+          by: :code
+        },
+        set: :marital_status_id,
+        value: :marital_status,
+        with: :id
+      }
+    ]
+  end
+
+  let(:omitted) do
+    { patient_id: 1 }
+  end
+
+  let(:filled) do
+    { patient_id: 2, patient_status: 'active', marital_status: 'single' }
+  end
+
+  let(:mismatched) do
+    { patient_id: 2, patient_status: 'doesnt_exist', marital_status: 'no_exist' }
+  end
+
+  describe '#add' do
+    it 'raises ArgumentError when name is nil' do
+      expect { subject.add(nil, {}) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises ArgumentError when name is empty string' do
+      expect { subject.add('', {}) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#add_each' do
+    it 'raises ArgumentError when name is nil' do
+      expect { subject.add_each(nil, []) }.to raise_error(ArgumentError)
+    end
+
+    it 'raises ArgumentError when name is empty string' do
+      expect { subject.add_each('', []) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#map' do
+    context 'with nil input' do
+      it 'returns base mapped hash' do
+        expected = {
+          patient_status_id: nil,
+          marital_status_id: nil
+        }
+
+        actual = subject.map(nil)
+
+        expect(actual).to eq(expected)
+      end
+    end
+
+    context 'with missing keys input' do
+      it 'returns hash with nil values' do
+        expected = omitted.merge(
+          patient_status_id: nil,
+          marital_status_id: nil
+        )
+
+        actual = subject.map(omitted)
+
+        expect(actual).to eq(expected)
+      end
+    end
+
+    context 'with present keys input' do
+      it 'returns hash with values' do
+        expected = filled.merge(
+          patient_status_id: 1,
+          marital_status_id: 1
+        )
+
+        actual = subject.map(filled)
+
+        expect(actual).to eq(expected)
+      end
+    end
+
+    context 'with present keys input but no values match lookups' do
+      it 'returns hash with nil values' do
+        expected = mismatched.merge(
+          patient_status_id: nil,
+          marital_status_id: nil
+        )
+
+        actual = subject.map(mismatched)
+
+        expect(actual).to eq(expected)
+      end
+    end
+  end
+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