differential 1.0.5 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 338faf87efae2afbc60eaa95b20fbfe0cddbf410
-  data.tar.gz: 91afe0b117f23e33f86be2df86169fa23111152c
+  metadata.gz: fa747f8e377b675d626c4c49cd31f84a73ca9bf8
+  data.tar.gz: 4c3af655ca69988cffa9928a3debb84eaeb8206b
 SHA512:
-  metadata.gz: 6a27dc65828848113eba8c0128ac39d791e2962e29ec7cfaa44e01bba160a057f5fff7b1d43d35de3fad9337316d67d75a6033e733810f41f7dd55f2d6c7c812
-  data.tar.gz: fd0615b537efe24c4df38615abe47f082447dc3299d60724978aac18e6c0d4c926a9dbf694bf06677fafbf630d7349c24894755036df6f45601dbe8a5b65cc4b
+  metadata.gz: 6758f520698fa56574aa43b44e52a798db2c116200abea0ecbae1f14df36171d8f407e4755522ff70b95ac6328fc6117511a2efa11c8552bea0ed59e7d167eb9
+  data.tar.gz: b9e7a247c19f542fdc06783b324612d4a1d7ee6f7f8c43ece8f2925a175be1b13b0ac113cd852138f1d412eb621b0f2951a85685cfa1b2f353a9bc5e54e9b4f3

data/.gitignore

@@ -1,2 +1,3 @@
 .DS_Store
 *.gem
+/tmp

data/.travis.yml

@@ -2,11 +2,9 @@ language: ruby
 rvm:
 - 2.3.1
 - 2.3.7
+- 2.3.8
+- 2.6.0
 cache: bundler
 script:
 - bundle exec rubocop
 - bundle exec rspec
-notifications:
-  hipchat:
-    rooms:
-      secure: OpIo19mre1zR5gJlr1T7BD/jVBYadikM49ueC4HWPt3Wln6LlNM3G1gcXVw4A5Ppd7p+6251aOhLHA44HdjXSo+VrhfgiFO9tfkyNuVIrLxeZr/eQwEnv1JJlPJdL/y2sGsBS5WRIgo+txIkLflQ0zoDpvnR6zkWRaRYZcRWo+X9Q890VHRR0emHURX5Kqsi5sJjHac69uIRbEAtlvdd1KnfNXF6+2udMnH6Kb4BxrSUp6voQ+VTyTGM4f2uMInxvjTVNzCCLgb4zBa5KwZNjjLRXWwIsWC0jVia0IRNskaeoFkFQxsVb33kq55t8XxR/ZuHUr5exFUazPnEc3ht9L/GOCYX4qFwbVPyxwyVZ64hHLx3E5g4ozlVCvBH3MDqkoasep7x+Ml8RuA6lSM2hIM88Eo5g98wpXW2WPiHUTxbtIc/2qKTmMKPZI+J23tuR7kza/5kGyPlqKA5OXr++0MFIUtFhWs1iSSQnq0Anssfxd1EhXPKqR/vqpQVgNSpv/cJOMQInPHSkvcq7kMRQWxka9uXHFT1+YH3kYCsAB30bdp8IPMNKQuemGhqS7GZXke9M32Yx9TKykGyAkzv6NGSc1pUAEViGHuydm6mTdvXYBfTQ3ZE6SIP+Rx5/WCyAyPerADPMI26enlFzzSPucdVU8wErceH1Uq7AleVNFw=

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 1.0.6 (January 11, 2019)
+
+- Added Data Peeking for groups and items (group#data_peek, item#data_peek methods).
+- Changed precision of Totals a_sigma, b_sigma, and delta to be BigDecimal with precision of 6.
+
+## 1.0.5 (January 11, 2019)
+
+- Added lexicographic ID sorting (report#sorted_groups and group#sorted_items methods.)
+
 ## 1.0.4 (December 21, 2018)
 
 - Adjusted reader so it stores multipart ID's properly in the ID's data field.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    differential (1.0.5)
+    differential (1.0.6)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -184,7 +184,33 @@ reader_config = {
 }
 ```
 
-In this example we are showing that a unique identifier for an employee is not just the employee's ID, but also the companies ID.  The above configuration would output a dataset that is grouped by transport type and direction (i.e. Outbound Train, Inbound Train, Outbound Car, etc...) and lists each unique employee per company in each group.  
+In this example we are showing that a unique identifier for an employee is not just the employee's ID, but also the companies ID.  The above configuration would output a dataset that is grouped by transport type and direction (i.e. Outbound Train, Inbound Train, Outbound Car, etc...) and lists each unique employee per company in each group.
+
+### Data Peeking
+
+*Raw data* is defined as the initial dataset(s) passed into Differential#calculate.  The consumer application defines this raw data and what Differential does is parses, interprets, and pivots it based on the configuration sent in.  By the time Differential is complete you will end up with a completely different result set than initially passed in.  This does not mean you cannot trace back the raw data.
+
+You still have access to the raw data after the data has been consumed and calculated within a report.  An example of accessing this on a specific item would be:
+
+````
+item.data_peek(:name)
+````
+
+In the above example, the item would the first record added (precedence to side A, then B) and execute the field on the record's data value.  If the data value is a hash, it will send it through the brackets [] method, if the data value is an object, it will check to see if it responds to field and call it if it can.
+
+If you want to only check one side, you can also specify the side:
+
+````
+item.data_peek(:name, ::Differential::Calculator::Side::A) # item.data_peek(:name, :a)
+item.data_peek(:name, ::Differential::Calculator::Side::B) # item.data_peek(:name, :b)
+````
+
+Data peeking also works at the group level, where it will look at the first item added:
+
+````
+group.data_peek(:name)
+````
+
 
 ## Contributing
 

data/lib/differential/calculator/group.rb

@@ -45,8 +45,17 @@ module Differential
         self
       end
 
+      def data_peek(field, side = nil)
+        first_item&.data_peek(field, side)
+      end
+
       private
 
+      def first_item
+        # first() will return an array: [key, value], but we just want the value.
+        @items_by_id.first&.last
+      end
+
       def upsert_item(record, side)
         item_id_key = record.id.value
         item_id     = record.id

data/lib/differential/calculator/item.rb

@@ -40,8 +40,30 @@ module Differential
         self
       end
 
+      def data_peek(field, side = nil)
+        data_object = record_peek(side)&.data
+
+        return nil unless data_object
+
+        if data_object.respond_to?(field)
+          data_object.send(field)
+        elsif data_object.respond_to?(:[])
+          data_object[field]
+        end
+      end
+
       private
 
+      def record_peek(side)
+        if [nil, A].include?(side) && a_records.any?
+          a_records
+        elsif [nil, B].include?(side) && b_records.any?
+          b_records
+        else
+          []
+        end.first
+      end
+
       def account_for_record(record, side)
         case side
         when A

data/lib/differential/calculator/totals.rb

@@ -16,15 +16,17 @@ module Differential
     class Totals
       include ::Differential::Calculator::Side
 
+      DIGITS = 6
+
       attr_reader :a_sigma,
                   :a_size,
                   :b_sigma,
                   :b_size
 
       def initialize
-        @a_sigma = 0
+        @a_sigma = BigDecimal(0, DIGITS)
         @a_size  = 0
-        @b_sigma = 0
+        @b_sigma = BigDecimal(0, DIGITS)
         @b_size  = 0
       end
 

data/lib/differential/differential.rb

@@ -8,6 +8,7 @@
 #
 
 require 'forwardable'
+require 'bigdecimal'
 
 require_relative 'calculator/calculator'
 require_relative 'parser/parser'

data/lib/differential/version.rb

@@ -8,5 +8,5 @@
 #
 
 module Differential
-  VERSION = '1.0.5'
+  VERSION = '1.0.6'
 end

data/spec/differential/calculator/group_spec.rb

@@ -41,4 +41,15 @@ describe ::Differential::Calculator::Group do
 
     expect(actual_ids).to eq(expected_ids)
   end
+
+  it 'should peek at data based on first item it finds' do
+    record = ::Differential::Parser::Record.new(id:       '1',
+                                                group_id: group_id,
+                                                value:    1,
+                                                data:     { name: 'Millie' })
+
+    group.add(record, ::Differential::Calculator::Side::A)
+
+    expect(group.data_peek(:name)).to eq(record.data[:name])
+  end
 end

data/spec/differential/calculator/item_spec.rb

@@ -10,11 +10,153 @@
 require './spec/spec_helper'
 
 describe ::Differential::Calculator::Item do
-  let(:id) { 'matt' }
+  let(:id) { '1' }
 
   let(:item) { ::Differential::Calculator::Item.new(id) }
 
   it 'should initialize correctly' do
     expect(item.id).to eq(id)
   end
+
+  context 'data peeking' do
+    let(:matt_data_hash) { { name: 'matt' } }
+
+    let(:matt_data_object) { OpenStruct.new(matt_data_hash) }
+
+    let(:matt_record) do
+      ::Differential::Parser::Record.new(
+        id: '1',
+        group_id: '1',
+        value: 1,
+        data: matt_data_hash
+      )
+    end
+
+    let(:matt_record_with_data_object) do
+      ::Differential::Parser::Record.new(
+        id: '1',
+        group_id: '1',
+        value: 1,
+        data: matt_data_object
+      )
+    end
+
+    let(:nick_record) do
+      ::Differential::Parser::Record.new(
+        id: '1',
+        group_id: '1',
+        value: 2,
+        data: { name: 'nick' }
+      )
+    end
+
+    let(:sam_record) do
+      ::Differential::Parser::Record.new(
+        id: '1',
+        group_id: '1',
+        value: 3,
+        data: { name: 'sam' }
+      )
+    end
+
+    let(:katie_record) do
+      ::Differential::Parser::Record.new(
+        id: '1',
+        group_id: '1',
+        value: 4,
+        data: { name: 'katie' }
+      )
+    end
+
+    it 'should work when data is an object' do
+      item.add(matt_record_with_data_object, ::Differential::Calculator::Side::A)
+
+      expect(item.data_peek(:name)).to eq(matt_data_object.name)
+    end
+
+    it 'should work when data is a hash' do
+      item.add(matt_record, ::Differential::Calculator::Side::A)
+
+      expect(item.data_peek(:name)).to eq(matt_data_hash[:name])
+    end
+
+    context 'when side is nil' do
+      it 'should peek side A when both sides have records' do
+        item.add(matt_record,   ::Differential::Calculator::Side::A)
+        item.add(nick_record,   ::Differential::Calculator::Side::A)
+        item.add(sam_record,    ::Differential::Calculator::Side::B)
+        item.add(katie_record,  ::Differential::Calculator::Side::B)
+
+        expect(item.data_peek(:name)).to eq(matt_record.data[:name])
+      end
+
+      it 'should peek side A when only side A has records' do
+        item.add(matt_record,   ::Differential::Calculator::Side::A)
+        item.add(nick_record,   ::Differential::Calculator::Side::A)
+
+        expect(item.data_peek(:name)).to eq(matt_record.data[:name])
+      end
+
+      it 'should peek side B when only side B has records' do
+        item.add(sam_record,    ::Differential::Calculator::Side::B)
+        item.add(katie_record,  ::Differential::Calculator::Side::B)
+
+        expect(item.data_peek(:name)).to eq(sam_record.data[:name])
+      end
+    end
+
+    context 'when side is A' do
+      let(:side) { ::Differential::Calculator::Side::A }
+
+      it 'should peek side A when both sides have records' do
+        item.add(matt_record,   ::Differential::Calculator::Side::A)
+        item.add(nick_record,   ::Differential::Calculator::Side::A)
+        item.add(sam_record,    ::Differential::Calculator::Side::B)
+        item.add(katie_record,  ::Differential::Calculator::Side::B)
+
+        expect(item.data_peek(:name, side)).to eq(matt_record.data[:name])
+      end
+
+      it 'should peek side A when only side A has records' do
+        item.add(matt_record,   ::Differential::Calculator::Side::A)
+        item.add(nick_record,   ::Differential::Calculator::Side::A)
+
+        expect(item.data_peek(:name, side)).to eq(matt_record.data[:name])
+      end
+
+      it 'should return nil when only side B has records' do
+        item.add(sam_record,    ::Differential::Calculator::Side::B)
+        item.add(katie_record,  ::Differential::Calculator::Side::B)
+
+        expect(item.data_peek(:name, side)).to eq(nil)
+      end
+    end
+
+    context 'when side is B' do
+      let(:side) { ::Differential::Calculator::Side::B }
+
+      it 'should peek side B when both sides have records' do
+        item.add(matt_record,   ::Differential::Calculator::Side::A)
+        item.add(nick_record,   ::Differential::Calculator::Side::A)
+        item.add(sam_record,    ::Differential::Calculator::Side::B)
+        item.add(katie_record,  ::Differential::Calculator::Side::B)
+
+        expect(item.data_peek(:name, side)).to eq(sam_record.data[:name])
+      end
+
+      it 'should peek side B when only side B has records' do
+        item.add(sam_record,    ::Differential::Calculator::Side::B)
+        item.add(katie_record,  ::Differential::Calculator::Side::B)
+
+        expect(item.data_peek(:name, side)).to eq(sam_record.data[:name])
+      end
+
+      it 'should return nil when only side A has records' do
+        item.add(matt_record,   ::Differential::Calculator::Side::A)
+        item.add(nick_record,   ::Differential::Calculator::Side::A)
+
+        expect(item.data_peek(:name, side)).to eq(nil)
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -7,4 +7,6 @@
 # LICENSE file in the root directory of this source tree.
 #
 
+require 'ostruct'
+
 require './lib/differential'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: differential
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-27 00:00:00.000000000 Z
+date: 2019-01-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard-rspec