eco-helpers 2.6.3 → 2.7.0

data/lib/eco/data/hashes/array_diff.rb

@@ -8,17 +8,16 @@ module Eco
 
         include Eco::Language::AuxiliarLogger
 
-        attr_reader :source1, :source2
-        attr_reader :src_h1,  :src_h2
-
-        def initialize(source1, source2, logger: nil)
-          @logger  = logger if logger
-          @source1 = source1
-          @source2 = source2
-          @src_h1  = by_key(source1)
-          @src_h2  = by_key(source2)
-          raise "Missing source1" unless !!self.src_h1
-          raise "Missing source2" unless !!self.src_h2
+        attr_reader :source_1, :source_2
+        attr_reader :src_h_1, :src_h_2
+
+        def initialize(source_1, source_2, logger: nil)
+          @logger   = logger if logger
+          @source_1 = source_1
+          @source_2 = source_2
+
+          raise "Missing source_1" unless (@src_h_1 = by_key(source_1))
+          raise "Missing source_2" unless (@src_h_2 = by_key(source_2))
         end
 
         # @note
@@ -26,35 +25,31 @@ module Eco
         #   - It also allows to know the original value
         # @return [Hash] where `key` is the key of the record, and `value` a `DiffResult` object
         def diffs
-          @diffs ||= source_results.select do |res|
-            res.diff?
-          end
+          @diffs ||= source_results.select(&:diff?)
         end
 
         # @return [Boolean] wheter or not there are differences.
         def diffs?
-          !diffs.empty?
+          diffs.any?
         end
 
         # All the items that contain the diff of a node.
         # @return [Array<Eco::Data::Hash::DiffResult>]
         def source_results
-          @source_results ||= paired_sources.each_with_object([]) do |(src1, src2), res|
-            res << diff_result_class.new(src1, src2)
+          @source_results ||= paired_sources.each_with_object([]) do |(src_1, src_2), res|
+            res << diff_result_class.new(src_1, src_2)
           end
         end
 
         protected
 
-        # It pairs the hashes of `source1` and `source2`
+        # It pairs the hashes of `source_1` and `source_2`
         # @note
         #   - It also ensures they are in their Hash form (with string keys)
         #   - This will merge entries of the same source that hold the same `key` attr value (latest wins)
         def paired_sources
-          keys1    = src_h1.keys
-          keys2    = src_h2.keys
-          all_keys = keys1 | keys2
-          all_keys.map {|key| [src_h1[key], src_h2[key]]}
+          all_keys = src_h_1.keys | src_h_2.keys
+          all_keys.map {|key| [src_h_1[key], src_h_2[key]]}
         end
 
         # @return [String] the `key` attribute of `diff_result_class`
@@ -68,22 +63,14 @@ module Eco
           diff_result_class.case_sensitive?
         end
 
-        def compared_attrs
-          diff_result_class.compared_attrs.map(&:to_s)
-        end
-
         private
 
         def symbolize_keys(hash)
-          hash.each_with_object({}) do |(k, v), h|
-            h[k.to_sym] = v
-          end
+          hash.transform_keys(&:to_sym)
         end
 
         def stringify_keys(hash)
-          hash.each_with_object({}) do |(k, v), h|
-            h[k.to_s] = v
-          end
+          hash.transform_keys(&:to_s)
         end
 
         def by_key(content)
@@ -95,7 +82,9 @@ module Eco
         def to_array_of_hashes(content)
           case content
           when Hash
-            logger.error("Input data as 'Hash' not supported. Expecting 'Enumerable' or 'String'")
+            log(:error) {
+              "(ArrayDiff) Input data as 'Hash' not supported. Expecting 'Enumerable' or 'String'"
+            }
             exit(1)
           when String
             to_array_of_hashes(Eco::CSV.parse(content))
@@ -106,13 +95,13 @@ module Eco
               Eco::CSV::Table.new(content).to_array_of_hashes
             else
               log(:error) {
-                "Input content 'Array' of '#{sample.class}' is not supported."
+                "(ArrayDiff) Input content 'Array' of '#{sample.class}' is not supported."
               }
               exit(1)
             end
           else
             log(:error) {
-              "Could not obtain any data out content: '#{content.class}'"
+              "(ArrayDiff) Could not obtain any data out content: '#{content.class}'"
             }
             exit(1)
           end

data/lib/eco/data/hashes/diff_result/meta.rb

@@ -0,0 +1,131 @@
+module Eco
+  module Data
+    module Hashes
+      class DiffResult
+        module Meta
+          class << self
+            def included(base)
+              super(base)
+              base.extend Eco::Language::Models::ClassHelpers
+              base.extend ClassMethods
+              base.inheritable_class_vars :key, :compared_attrs, :case_sensitive
+            end
+          end
+
+          module ClassMethods
+            # @param value [String, NilClass]
+            # @return [String] the attribute that is key of the node diff elements.
+            def key(value = nil)
+              return @key unless value
+              @key = value.to_s
+            end
+
+            # @return [Boolean] is there a `key` attribute defined?
+            def key?
+              !!@key
+            end
+
+            # @param attrs [Array<Symbol>, Array<String>]
+            # @return [Array<String>] the comparable attributes
+            def compare(*attrs, when_present: false)
+              if when_present
+                compared_attrs_when_present.push(*attrs.map(&:to_s)).uniq!
+                compared_attrs_when_present
+              else
+                compared_attrs.push(*attrs.map(&:to_s)).uniq!
+                compared_attrs
+              end
+            end
+
+            # Whether or not the diff calc of a node should be done case sensitive or insensitive.
+            def case_sensitive(value = nil)
+              @case_sensitive = false unless instance_variable_defined?(:@case_sensitive)
+              return @case_sensitive unless value
+              @case_sensitive = !!value
+            end
+
+            # @return [Boolean] are comparisons of values done case sensitive?
+            def case_sensitive?
+              !!@case_sensitive
+            end
+
+            # @return [Array<String>] the comparable attributes
+            def compared_attrs
+              @compared_attrs ||= []
+            end
+
+            # Same as `compared_attrs` but they only get compared when present
+            # in both data sources
+            # @note if present in one source but not in another,
+            #   that attribute will NOT generate a diff.
+            def compared_attrs_when_present
+              @compared_attrs_when_present ||= []
+            end
+
+            def all_compared_attrs
+              compared_attrs | compared_attrs_when_present
+            end
+
+            def compared_attr_when_present?(attr)
+              compared_attrs_when_present.include?(attr)
+            end
+          end
+
+          def key
+            self.class.key.dup
+          end
+
+          def case_sensitive?
+            self.class.case_sensitive?
+          end
+
+          def all_compared_attrs
+            self.class.all_compared_attrs.dup.compact.map(&:to_s)
+          end
+
+          private
+
+          # @return [Boolean] whether `val1` is equal to `val2`
+          def eq?(val_1, val_2)
+            return eq_ary?(val_1, val_2) if [val_1, val_2].any? {|v| v.is_a?(Array)}
+            return true  if val_1 == val_2
+            return false if case_sensitive?
+            return false unless val_2 && val_1
+            val_1.upcase == val_2.upcase
+          end
+
+          # Compares two arrays
+          # @note
+          #   1. Order does NOT matter
+          #   2. Repeated elements are treated as one
+          def eq_ary?(val_1, val_2)
+            return false unless [val_1, val_2].all? {|v| v.is_a?(Array)}
+            return true  if val_1 == val_2
+            v_1    = case_sensitive?? val_1 : val_1.map {|v| v&.upcase}
+            v_2    = case_sensitive?? val_2 : val_2.map {|v| v&.upcase}
+            joined = (v_1 | v_2)
+            (joined & v_1) == (joined & v_2)
+          end
+
+          # Hash access
+          # @note DSL to be able to modify behaviour
+          #   (i.e. indifferent access for camel and snake case keys)
+          def get_attr(src, key)
+            return nil unless src
+            src[key.to_s]
+          end
+
+          def slice_attrs(src, *keys)
+            return nil unless src
+            src.slice(*keys)
+          end
+
+          def key_present?(src, key)
+            return false unless src
+            src.key?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/data/hashes/diff_result.rb

@@ -1,53 +1,68 @@
+require_relative 'diff_result/meta'
+
 module Eco
   module Data
     module Hashes
       class DiffResult
-        extend Eco::Language::Models::ClassHelpers
-        include Eco::Data::Hashes::DiffMeta
-
-        inheritable_class_vars :key, :compared_attrs, :case_sensitive
+        include Eco::Data::Hashes::DiffResult::Meta
 
-        attr_reader :src1, :src2
+        attr_reader :src_1, :src_2
 
-        def initialize(src1, src2)
-          @src1 = src1
-          @src2 = src2
+        def initialize(src_1, src_2)
+          @src_1 = src_1
+          @src_2 = src_2
         end
 
-        def key
-          self.class.key
+        # @return [Value] the current value of `attr` (in `src_2`)
+        def attr(attr)
+          get_attr(src_2, attr)
         end
 
-        def case_sensitive?
-          self.class.case_sensitive?
+        # @return [Value] the previous value of `attr` (in `src_1`)
+        def attr_prev(attr)
+          get_attr(src_1, attr)
         end
 
-        def dup(src1: nil, src2: nil)
-          src1 ||= self.src1
-          src2 ||= self.src2
-          self.class.new(src1.dup, src2.dup)
+        # Deduplication to prevent mutability when manipulation is required.
+        def dup(src_1: nil, src_2: nil)
+          src_1 ||= self.src_1
+          src_2 ||= self.src_2
+          self.class.new(src_1.dup, src_2.dup)
         end
 
         def new?
-          !src1 && !!src2
+          src_2 && !src_1
         end
 
         def del?
-          !!src1 && !src2
+          src_1 && !src_2
         end
 
         def update?
           !new? && !del? && diff?
         end
 
+        # Uniq access point to identify attrs that have changed.
+        # @note when is `new?` or to be deleted (`del?`), there's nothing to compare.
+        # @return [Array<Symbol>] hash with the list of attrs that are different
+        #   between `src_1` and `src_2`.
+        def diff_attrs
+          return (@diff_attrs = []) if new? || del?
+          @diff_attrs ||= all_compared_attrs.each_with_object([]) do |kattr, out|
+            next unless comparable_attr?(kattr)
+            out << kattr unless eq?(attr_prev(kattr), attr(kattr))
+          end
+        end
+
         # @note `diff_attrs` may not include the `key` attribute
         #   This is always included via `new?` (new key value) and `del?` (missing key value)
         # @return [Boolean] was there any change?
         def diff?
-          new? || del? || !diff_attrs.empty?
+          new? || del? || diff_attrs.any?
         end
 
-        # Is the `key` attr value changing?
+        # Is the `key` attr value updated?
+        # @note that `new?` and `del?` won't be considered as key's change
         def key?
           !(new? || del?) && diff_attr?(key)
         end
@@ -59,54 +74,47 @@ module Eco
           diff_attrs.include?(attr.to_s)
         end
 
-        # @return [Value] the current value of `attr` (in `src2`)
-        def attr(attr)
-          return nil unless src2
-          src2[attr.to_s]
-        end
-
-        # @return [Value] the previous value of `attr` (in `src1`)
-        def attr_prev(attr)
-          return nil unless src1
-          src1[attr.to_s]
-        end
-
         # @note the `key` attribute will always be added (even if there's no change)
-        # @return [Hash] hash with the differences as per `src2`
+        # @return [Hash] hash with the differences as per `src_2`
         def diff_hash
-          target_attrs = [key] | compared_attrs
-          return src2.slice(*target_attrs) if new?
-          return src1.slice(key)           if del?
-          src2.slice(key, *diff_attrs)
+          target_attrs = [key] | all_compared_attrs
+          return slice_attrs(src_2, *target_attrs) if new?
+          return slice_attrs(src_1, key)           if del?
+          slice_attrs(src_2, key, *diff_attrs)
         end
 
-        # @return [Array<Symbol>] hash with the differences as per `src2`
-        def diff_attrs
-          @diff_attrs ||= comparable_attrs.each_with_object([]) do |attr, out|
-            out << attr unless eq?(src1[attr], src2[attr])
+        # Uniq access point to scope if an `attr` is in the scope of the diff compare.
+        # Set of attributes that are general target to identify differences
+        # between both sources.
+        # @note When the class `all_compared_attrs` has not been deefined,
+        #   it uses `all_source_keys`
+        # @return [Array<String>] the set of attributes that are comparable in this class.
+        def all_compared_attrs
+          super().map(&:to_s).uniq.tap do |attrs|
+            return all_source_keys unless attrs.any?
           end
         end
 
-        # @return [Boolean] whether `val1` is equal to `val2`
-        def eq?(val1, val2)
-          return true  if val1 == val2
-          return false if case_sensitive?
-          return false if !val2 || !val1
-          val1.upcase == val2.upcase
+        # All the keys that the data comes with
+        def all_source_keys
+          (src_1&.keys || []) & (src_2&.keys || [])
         end
 
-        # @note when is `new?` or to be deleted (`del?`), it returns empty array.
-        # @return [Array<String>] the set of attributes that are comparable in this instance.
-        def comparable_attrs
-          return [] if new? || del?
-          compared_attrs
+        private
+
+        # Refinement over `all_compared_attrs`, provided that those that must
+        # be comparable only **when present** in both, are filtered out when
+        # that is not the case.
+        def comparable_attr?(attr)
+          attr = attr.to_s
+          return false unless all_compared_attrs.include?(attr)
+          return true  unless self.class.compared_attr_when_present?(attr)
+          key_present_in_both?(attr)
         end
 
-        # @return [Array<String>] the set of attributes that are comparable in this class.
-        def compared_attrs
-          comp_attrs = self.class.compared_attrs.map(&:to_s).uniq
-          return comp_attrs unless comp_attrs.empty?
-          (src1&.keys || []) & (src2&.keys || [])
+        # Is the key `attr` present in both sources?
+        def key_present_in_both?(attr)
+          key_present?(src_1, attr) && key_present?(src_2, attr)
         end
       end
     end