invoca-utils 0.1.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 415752871460b9b105317298a448748ab21d3e66
-  data.tar.gz: f946ff261cbc342c34d3a82da9c1d4bb31328317
+SHA256:
+  metadata.gz: bc2c9db5fc433f7e4f0abfc7ba11ca6a41065e5a4e9a233bb6f38fa8d310e0d0
+  data.tar.gz: 426e3b56dcb95d79b964d613198b2c483050da092999a4ccd4e29348231b0588
 SHA512:
-  metadata.gz: dc7d2f1aa0a27e6afcdbcb32fecf90dd39e987145ef5d0f875711cc8631e676bc9551f8d761710426d3d7a96343c03e1b25a3a4fba0fc93b0fa610815385375f
-  data.tar.gz: ed4627548537d4c8d8d79c177a605f45920f494aa3e747b5b5585801e4837ebaf88db6c48035ad59bd4d7d89a87ba2eccf1c88028803036cc5c2262cb1ab68a5
+  metadata.gz: b0e762c4b3a2e044abc0a340dc741a9258b2a3afbca3caf575f5f160067fef863ce10d40b03bc374275d0953c9984fd0bf2253df8d5cdcc0e43774bbf42948fe
+  data.tar.gz: fc973c0be3d37b5f8e38f2e12d9ea45a87539c78ff8afe7b7f8adf8351d623f847af68a1d9df96bbc39938894dfb6e2bf2fe4f36ef182278f80b3511381cdedf

data/.gitignore

@@ -10,10 +10,12 @@ coverage
 doc/
 lib/bundler/man
 pkg
+pkg/
 rdoc
-spec/reports
+test/reports
 test/tmp
 test/version_tmp
+
 tmp
 *.bundle
 *.so
@@ -22,4 +24,3 @@ tmp
 mkmf.log
 .idea/
 .rubocop-http*
-test/reports

data/.jenkins/Jenkinsfile

@@ -0,0 +1,50 @@
+#!/usr/bin/groovy
+@Library('jenkins-pipeline@v0.4.5')
+import com.invoca.docker.*;
+pipeline {
+  agent {
+    kubernetes {
+      defaultContainer "ruby"
+      yamlFile ".jenkins/ruby_build_pod.yml"
+    }
+  }
+
+  environment {
+    GITHUB_TOKEN = credentials('github_token')
+    BUNDLE_GEM__FURY__IO = credentials('gemfury_deploy_token')
+  }
+
+  stages {
+    stage('Setup') {
+      steps {
+        script {
+          sh 'bundle install'
+        }
+      }
+    }
+    stage('Unit Test') {
+      steps {
+        script {
+          sh 'bundle exec rake'
+        }
+      }
+      post {
+        always { junit '*/reports/*.xml' }
+        success { updateGitHubStatus('clean-build', 'success', 'Unit tests.') }
+        failure { updateGitHubStatus('clean-build', 'failure', 'Unit tests.') }
+      }
+    }
+  }
+}
+
+void updateGitHubStatus(String context, String status, String description) {
+  gitHubStatus([
+    repoSlug:    'Invoca/invoca-utils',
+    sha:         env.GIT_COMMIT,
+    description: description,
+    context:     context,
+    targetURL:   env.BUILD_URL,
+    token:       env.GITHUB_TOKEN,
+    status:      status
+  ])
+}

data/.jenkins/ruby_build_pod.yml

@@ -0,0 +1,19 @@
+---
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+  jenkins/invoca-utils: 'true'
+  namespace: jenkins
+  name: invoca-utils
+spec:
+  containers:
+  - name: ruby
+    image: ruby:2.6.5
+    tty: true
+    resources:
+    requests:
+      memory: "100Mi"
+    command:
+      - cat
+

data/.ruby-version

@@ -1 +1 @@
-2.4.2
+2.6.5

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+# CHANGELOG for `invoca-utils`
+
+Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+Note: This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.4.1] - 2020-06-17
+### Fixed
+- Support Ruby < 2.5 by adding `begin`/`end` around `rescue` in `retry_on_exception`. 
+
+## [0.4.0] - 2020-06-09
+### Added
+- Added `Invoca::Utils.retry_on_exception`.
+- Added `Invoca::Utils::GuaranteedUTF8String.normalize_all_strings` to normalize
+  all strings found in a JSON doc of hashes, arrays, and values.
+
+## [0.3.0] - 2020-04-28
+### Added
+- Array::* operator changed to use alias_method instead of prepend to prevent infinite recursion when HoboSupport gem is present
+- Enumerable::map_and_find, map_with_index, and map_hash methods ported from HoboSupport
+- Hash::select_hash, map_hash, partition_hash, & and - methods ported from HoboSupport
+- HashWithIndifferentAccess::partition_hash, & and - methods ported from HoboSupport
+- Module::alias_method_chain ported from HoboSupport
+
+## [0.2.0] - 2020-04-27
+### Added
+- Enumerable::build_hash method ported from HoboSupport
+- Enumerable::* operator ported from HoboSupport
+
+[0.4.0]: https://github.com/Invoca/invoca-utils/compare/v0.3.0...v0.4.0
+[0.3.0]: https://github.com/Invoca/invoca-utils/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/Invoca/invoca-utils/compare/v0.1.1...v0.2.0

data/Gemfile

@@ -4,13 +4,19 @@ source 'https://rubygems.org'
 
 gemspec
 
-group :development do
+source 'https://rubygems.org' do
+  gem 'activesupport', '~> 4.2'
+  gem 'minitest'
+  gem 'minitest-reporters'
+  gem 'pry'
   gem 'rake'
-  gem 'test-unit', '= 1.2.3'
   gem 'rr',        '=1.1.2'
-  gem 'shoulda',   '= 3.5.0'
-  gem 'pry'
   gem 'ruby-prof'
-  gem 'minitest'
+  gem 'shoulda',   '= 3.5.0'
+  gem 'test-unit', '= 1.2.3'
   gem 'tzinfo'
 end
+
+source 'https://gem.fury.io/invoca' do
+  gem 'test_overrides',      '~> 0.13'
+end

data/Gemfile.lock

@@ -1,30 +1,39 @@
 PATH
   remote: .
   specs:
-    invoca-utils (0.1.1)
+    invoca-utils (0.4.1)
 
 GEM
   remote: https://rubygems.org/
+  remote: https://gem.fury.io/invoca/
   specs:
-    activesupport (5.1.4)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
+    activesupport (4.2.11.3)
       i18n (~> 0.7)
       minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
-    coderay (1.1.2)
-    concurrent-ruby (1.0.5)
-    hoe (3.16.2)
-      rake (>= 0.8, < 13.0)
-    i18n (0.9.1)
+    ansi (1.5.0)
+    builder (3.2.4)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.6)
+    hoe (3.22.1)
+      rake (>= 0.8, < 15.0)
+    i18n (0.9.5)
       concurrent-ruby (~> 1.0)
-    method_source (0.9.0)
-    minitest (5.11.1)
-    pry (0.11.3)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rake (12.3.0)
+    method_source (1.0.0)
+    minitest (5.14.1)
+    minitest-reporters (1.4.2)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (13.0.1)
     rr (1.1.2)
-    ruby-prof (0.17.0)
+    ruby-prof (1.4.1)
+    ruby-progressbar (1.10.1)
     shoulda (3.5.0)
       shoulda-context (~> 1.0, >= 1.0.1)
       shoulda-matchers (>= 1.4.1, < 3.0)
@@ -33,23 +42,27 @@ GEM
       activesupport (>= 3.0.0)
     test-unit (1.2.3)
       hoe (>= 1.5.1)
+    test_overrides (0.13.0)
     thread_safe (0.3.6)
-    tzinfo (1.2.4)
+    tzinfo (1.2.7)
       thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activesupport (~> 4.2)!
   invoca-utils!
-  minitest
-  pry
-  rake
-  rr (= 1.1.2)
-  ruby-prof
-  shoulda (= 3.5.0)
-  test-unit (= 1.2.3)
-  tzinfo
+  minitest!
+  minitest-reporters!
+  pry!
+  rake!
+  rr (= 1.1.2)!
+  ruby-prof!
+  shoulda (= 3.5.0)!
+  test-unit (= 1.2.3)!
+  test_overrides (~> 0.13)!
+  tzinfo!
 
 BUNDLED WITH
    1.17.3

data/Rakefile

@@ -3,15 +3,10 @@
 
 require "bundler/gem_tasks"
 require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
-end
+require 'rake_test_warning_false'
 
 task default: :test
 
-task :default => 'test'
-
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
+end

data/invoca-utils.gemspec

@@ -1,4 +1,4 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'invoca/utils/version'
 
@@ -7,8 +7,7 @@ Gem::Specification.new do |spec|
   spec.version       = Invoca::Utils::VERSION
   spec.authors       = ["Invoca development"]
   spec.email         = ["development@invoca.com"]
-  spec.summary       = %q{A public collection of helpers used in multiple projects}
-  spec.description   = %q{A public collection of helpers used in multiple projects}
+  spec.summary       = "A public collection of helpers used in multiple projects"
   spec.homepage      = ""
   spec.license       = "MIT"
 

data/lib/invoca/utils.rb

@@ -1,19 +1,25 @@
 # frozen_string_literal: true
 
+module Invoca
+  module Utils
+  end
+end
+
+require "invoca/utils/module"
+require "invoca/utils/array"
+require "invoca/utils/enumerable"
 require "invoca/utils/diff"
+require "invoca/utils/hash"
+require "invoca/utils/hash_with_indifferent_access"
 require "invoca/utils/http"
 require "invoca/utils/map_compact"
 require "invoca/utils/min_max"
 require "invoca/utils/stable_sort"
 require "invoca/utils/time"
+require "invoca/utils/exceptions"
 require "invoca/utils/guaranteed_utf8_string"
 require "invoca/utils/version"
 
-module Invoca
-  module Utils
-  end
-end
-
 unless defined?(Diff)
   Diff = Invoca::Utils::Diff
 end

data/lib/invoca/utils/array.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative './multi_sender'
+
+# Invoca ::Array extensions
+# TODO: Once the hobo_support gem is no longer used by any of our code, use prepend instead of alias
+class Array
+
+  alias_method :original_multiply_operator, :* # rubocop:disable Style/Alias
+
+  def *(rhs = nil)
+    if rhs
+      original_multiply_operator(rhs)
+    else
+      Invoca::Utils::MultiSender.new(self, :map)
+    end
+  end
+end

data/lib/invoca/utils/enumerable.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative './multi_sender'
+
+# Invoca ::Enumerable extensions
+module Enumerable
+  def map_and_find(not_found = nil)
+    each do |x|
+      val = yield(x)
+      return val if val
+    end
+    not_found
+  end
+
+  def map_with_index(res = [])
+    each_with_index do |x, i|
+      res << yield(x, i)
+    end
+    res
+  end
+
+  def build_hash(res = {})
+    each do |x|
+      pair = block_given? ? yield(x) : x
+      res[pair.first] = pair.last if pair
+    end
+    res
+  end
+
+  def map_hash(res = {})
+    each do |x|
+      v = yield x
+      res[x] = v
+    end
+    res
+  end
+
+  def *
+    Invoca::Utils::MultiSender.new(self, :map)
+  end
+end

data/lib/invoca/utils/exceptions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Invoca
+  module Utils
+    class << self
+      # Yields and rescues any exceptions given in `exception_classes`, retrying the given number of times.
+      # The final retry does not rescue any exceptions.
+      # The try number (0..retries) is yielded as a block param.
+      #
+      # @param [Class or Array(Class)] exception_classes - exception()s) to rescue
+      # @param [Integer] retries: - 1+ count of retries (1 retry = up to 2 tries total)
+      # @param [Proc] before_retry - optional proc which is called before each retry, with the exception passed as a block param
+      # @return the value from yield
+      def retry_on_exception(exception_classes, retries: 1, before_retry: nil)
+        retries.times do |attempt_number|
+          begin
+            return yield(attempt_number)
+          rescue *Array(exception_classes) => ex
+            before_retry&.call(ex)
+          end
+        end
+
+        yield(retries)   # no rescue for this last try, so any exceptions will raise out
+      end
+    end
+  end
+end

data/lib/invoca/utils/guaranteed_utf8_string.rb

@@ -21,6 +21,7 @@ module Invoca
       REPLACE_CHARACTER = '~'
 
       class << self
+        # normalizes a string to UTF-8
         def normalize_string(orig_string,
                              normalize_utf16:              true,
                              normalize_cp1252:             true,
@@ -43,6 +44,22 @@ module Invoca
                                      replace_unicode_beyond_ffff: replace_unicode_beyond_ffff)
         end
 
+        # Walks a JSON doc of hashes, arrays, and values and normalizes all strings found to UTF-8
+        def normalize_all_strings(value, **options)
+          case value
+          when Hash
+            value.each_with_object({}) do |(k, v), result|
+              result[normalize_all_strings(k, **options)] = normalize_all_strings(v, **options)
+            end
+          when Array
+            value.map { |v| normalize_all_strings(v, **options) }
+          when String
+            normalize_string(value, **options)
+          else
+            value
+          end
+        end
+
         private
 
         def normalize_string_from_utf8(string,
@@ -54,13 +71,11 @@ module Invoca
           found_utf_16 = normalize_utf_16(string, normalize_cp1252: normalize_cp1252) if normalize_utf16
           if found_utf_16
             string.encode!('UTF-8')
-          else
-            unless string.valid_encoding?
-              if normalize_cp1252
-                cp1252_to_utf_8(string)
-              else
-                raise ArgumentError, 'Could not normalize to utf8 due to invalid characters (probably CP1252)'
-              end
+          elsif !string.valid_encoding?
+            if normalize_cp1252
+              cp1252_to_utf_8(string)
+            else
+              raise ArgumentError, 'Could not normalize to utf8 due to invalid characters (probably CP1252)'
             end
           end
           normalize_newlines(string)           if normalize_newlines

data/lib/invoca/utils/hash.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Invoca ::Hash extensions
+class Hash
+  def select_hash(&block)
+    res = {}
+    each { |k, v| res[k] = v if (block.arity == 1 ? yield(v) : yield(k, v)) } # rubocop:disable Style/ParenthesesAroundCondition
+    res
+  end
+
+  def map_hash(&block)
+    res = {}
+    each { |k, v| res[k] = block.arity == 1 ? yield(v) : yield(k, v) }
+    res
+  end
+
+  def partition_hash(keys = nil)
+    yes = {}
+    no = {}
+    each do |k, v|
+      if block_given? ? yield(k, v) : keys.include?(k)
+        yes[k] = v
+      else
+        no[k] = v
+      end
+    end
+    [yes, no]
+  end
+
+  # rubocop:disable Naming/BinaryOperatorParameterName
+  def -(keys)
+    res = {}
+    each_pair { |k, v| res[k] = v unless k.in?(keys) }
+    res
+  end
+
+  def &(keys)
+    res = {}
+    keys.each { |k| res[k] = self[k] if has_key?(k) }
+    res
+  end
+  # rubocop:enable Naming/BinaryOperatorParameterName
+end

data/lib/invoca/utils/hash_with_indifferent_access.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Invoca ::HashWithIndifferentAccess extensions
+if defined? HashWithIndifferentAccess
+
+  class HashWithIndifferentAccess
+
+    # rubocop:disable Naming/BinaryOperatorParameterName
+    def -(keys)
+      res = HashWithIndifferentAccess.new
+      keys = keys.map { |k| k.is_a?(Symbol) ? k.to_s : k }
+      each_pair { |k, v| res[k] = v unless k.in?(keys) }
+      res
+    end
+
+    def &(keys)
+      res = HashWithIndifferentAccess.new
+      keys.each do |k|
+        k = k.to_s if k.is_a?(Symbol)
+        res[k] = self[k] if has_key?(k)
+      end
+      res
+    end
+    # rubocop:enable Naming/BinaryOperatorParameterName
+
+    def partition_hash(keys = nil)
+      keys = keys&.map { |k| k.is_a?(Symbol) ? k.to_s : k }
+      yes = HashWithIndifferentAccess.new
+      no = HashWithIndifferentAccess.new
+      each do |k, v|
+        if block_given? ? yield(k, v) : keys.include?(k)
+          yes[k] = v
+        else
+          no[k] = v
+        end
+      end
+      [yes, no]
+    end
+
+  end
+
+end

data/lib/invoca/utils/module.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Module
+
+  # Custom alias_method_chain that won't cause infinite recursion if called twice.
+  # NOTE: Calling alias_method_chain on alias_method_chain was just way too confusing, so I copied it :-/
+  def alias_method_chain(target, feature)
+    # Strip out punctuation on predicates, bang or writer methods since
+    # e.g. target?_without_feature is not a valid method name.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1 # rubocop:disable Style/PerlBackrefs
+    yield(aliased_target, punctuation) if block_given?
+
+    with_method = "#{aliased_target}_with_#{feature}#{punctuation}"
+    without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
+
+    unless method_defined?(without_method)
+      alias_method without_method, target
+      alias_method target, with_method
+
+      if public_method_defined?(without_method)
+        public target
+      elsif protected_method_defined?(without_method)
+        protected target
+      elsif private_method_defined?(without_method)
+        private target
+      end
+    end
+  end
+end

data/lib/invoca/utils/multi_sender.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Invoca
+  module Utils
+    class MultiSender
+      undef_method(*(instance_methods - [:__id__, :__send__, :object_id]))
+
+      def initialize(enumerable, method)
+        @enumerable = enumerable
+        @method     = method
+      end
+
+      # rubocop:disable Style/MethodMissingSuper
+      # rubocop:disable Style/MissingRespondToMissing
+      def method_missing(name, *args, &block)
+        @enumerable.send(@method) { |x| x.send(name, *args, &block) }
+      end
+      # rubocop:enable Style/MethodMissingSuper
+      # rubocop:enable Style/MissingRespondToMissing
+    end
+  end
+end

data/lib/invoca/utils/version.rb

@@ -2,6 +2,6 @@
 
 module Invoca
   module Utils
-    VERSION = "0.1.1"
+    VERSION = "0.4.1"
   end
 end

data/test/test_helper.rb

@@ -7,3 +7,8 @@ require 'pry'
 require 'active_support/all'
 
 require 'invoca/utils'
+require "minitest/reporters"
+Minitest::Reporters.use! [
+  Minitest::Reporters::DefaultReporter.new,
+  Minitest::Reporters::JUnitReporter.new
+]

data/test/unit/array_test.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/invoca/utils/array.rb'
+require_relative '../test_helper'
+
+class ArrayTest < Minitest::Test
+  context '* operator' do
+    should 'call the same method on each item in an array and return the results as an array' do
+      assert_equal([4, 5, 5], ['some', 'short', 'words'].*.length)
+    end
+
+    should 'handle methods with arguments' do
+      assert_equal(['om', 'ho', 'or'], ['some', 'short', 'words'].*.slice(1, 2))
+    end
+
+    should 'not alter normal behavior (multiplication) when there is a right hand side to the expression' do
+      assert_equal(['some', 'short', 'words', 'some', 'short', 'words'], ['some', 'short', 'words'] * 2)
+    end
+  end
+end

data/test/unit/enumerable_test.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative '../../lib/invoca/utils/enumerable.rb'
+require_relative '../test_helper'
+
+class EnumerableTest < Minitest::Test
+
+  context 'map_and_find' do
+    should 'return the mapped value of the first match' do
+      assert_equal('FOUND 3', [1, 2, 3, 4].map_and_find { |v| 'FOUND 3' if v == 3 })
+    end
+
+    should 'return the mapped value of the first match, even if there are multiple matches' do
+      assert_equal('FOUND 3', [1, 2, 3, 4].map_and_find { |v| "FOUND #{v}" if v > 2 })
+    end
+
+    should 'return the provided argument if the value is not found' do
+      assert_equal('NOT FOUND', [1, 2, 3, 4].map_and_find('NOT FOUND') { |v| "FOUND 6" if v == 6 })
+    end
+
+    should 'return nil if the value is not found and no argument is provided' do
+      assert_nil([1, 2, 3, 4].map_and_find { |v| "FOUND 6" if v == 6 })
+    end
+  end
+
+  context 'map_with_index' do
+    should 'call the block with the value and index' do
+      assert_equal([10, 21, 32, 43], [10, 20, 30, 40].map_with_index { |v, index| v + index })
+    end
+
+    should 'assumulate into the provided enumerable' do
+      assert_equal([1, 10, 21, 32, 43], [10, 20, 30, 40].map_with_index([1]) { |v, index| v + index })
+    end
+  end
+
+  context 'map_hash' do
+    should 'convert enumerables into a hash using the value for key and the map result as the hash value' do
+      assert_equal({ 1 => 11, 2 => 12, 3 => 13 }, [1, 2, 3].map_hash { |v| v + 10  })
+    end
+
+    should 'includes nils returned from map' do
+      assert_equal({ 1 => 11, 2 => nil, 3 => 13 }, [1, 2, 3].map_hash { |v| v + 10 unless v == 2  })
+    end
+  end
+
+  context 'build_hash' do
+    should 'convert arrays of [key, value] to a hash of { key => value }' do
+      assert_equal({ 'some' => 4, 'short' => 5, 'words' => 5 }, ['some', 'short', 'words'].build_hash { |s| [s, s.length] })
+    end
+
+    should 'ignore nils returned from map' do
+      assert_equal({ 'some' => 4, 'words' => 5 }, ['some', 'short', 'words'].build_hash { |s|  s == 'short' ? nil : [s, s.length] })
+    end
+
+    # these seem like erroneous behavior, but, they have been left as-is for backward compatibility with hobosupport::Enumerable::build_hash
+
+    should 'convert arrays of [single_value] to a hash of { single_value => single_value }' do
+      assert_equal({ 'some' => 4, 'short' => 'short', 'words' => 5 }, ['some', 'short', 'words'].build_hash { |s| s == 'short' ? [s] : [s, s.length] })
+    end
+
+    should 'convert arrays of [first, ..., last] to a hash of { first => last }' do
+      assert_equal({ 'some' => 4, 'short' => 'three', 'words' => 5 }, ['some', 'short', 'words'].build_hash { |s| s == 'short' ? [s, 'two', 'three'] : [s, s.length] })
+    end
+
+    should 'convert empty arrays to a hash of { nil => nil }' do
+      assert_equal({ 'some' => 4, nil => nil, 'words' => 5 }, ['some', 'short', 'words'].build_hash { |s| s == 'short' ? [] : [s, s.length] })
+    end
+  end
+
+  context '* operator' do
+    should 'call the same method on each item in an Set and return the results as an array' do
+      assert_equal([4, 5, 5], Set['some', 'short', 'words'].*.length)
+    end
+
+    should 'call the same method on each item in an Hash and return the results as an array' do
+      assert_equal(['key1:value1', 'key2:value2'], { key1: 'value1', key2: 'value2' }.*.join(':'))
+    end
+  end
+end

data/test/unit/exceptions_test.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+
+class ExceptionsTest < Minitest::Test
+  context "exceptions" do
+    context ".retry_on_exception" do
+      should "default retries: to 1" do
+        times = 0
+        tries = []
+        result = Invoca::Utils.retry_on_exception(ArgumentError) do |try|
+          tries << try
+          times += 1
+        end
+        assert_equal 1, result
+        assert_equal [0], tries
+      end
+
+      context "when never raising an exception" do
+        should "return result" do
+          times = 0
+          tries = []
+          result = Invoca::Utils.retry_on_exception(ArgumentError, retries: 2) do |try|
+            tries << try
+            times += 1
+            try == 0 and raise ArgumentError, '!!!'
+            times
+          end
+          assert_equal 2, result
+          assert_equal [0, 1], tries
+        end
+      end
+
+      context "when always raising an exception" do
+        should "retry and finally raise" do
+          tries = []
+          assert_raises(ArgumentError, /!!! 2/) do
+            Invoca::Utils.retry_on_exception(ArgumentError, retries: 1) do |try|
+              tries << try
+              raise ArgumentError, "!!! #{try + 1}"
+            end
+          end
+          assert_equal [0, 1], tries
+        end
+      end
+
+      context "when raising but then succeeding" do
+        should "retry and finally return result" do
+          times = 0
+          result = Invoca::Utils.retry_on_exception(ArgumentError, retries: 1) do
+            times += 1
+            if times == 1
+              raise ArgumentError, "!!! #{times}"
+            else
+              times
+            end
+          end
+          assert_equal 2, result
+        end
+      end
+
+      context "when raising different exceptions (array notation) but then succeeding" do
+        should "retry and finally return result" do
+          times = 0
+          tries = []
+          result = Invoca::Utils.retry_on_exception([ArgumentError, RuntimeError], retries: 2) do |try|
+            tries << try
+            times += 1
+            case times
+            when 1
+              raise ArgumentError, "!!! #{times}"
+            when 2
+              raise RuntimeError, "!!! #{times}"
+            else
+              times
+            end
+          end
+          assert_equal 3, result
+          assert_equal [0, 1, 2], tries
+        end
+      end
+    end
+  end
+end

data/test/unit/guaranteed_utf8_string_test.rb

@@ -221,6 +221,29 @@ class GuaranteedUTF8StringTest < Minitest::Test
           assert_equal Encoding::UTF_8, encoded_string.encoding
         end
       end
+
+      context ".normalize_strings" do
+        should "walk json doc, replacing strings in: values, inside array elements, and hash keys and values" do
+          json_doc = {
+            '😹' => "\xE2\x9C\x93 laughing cat",
+            ['😹'] => ["\xE2", "\xf0\x9f\x98\xb9", { "newline" => "\r\n" }],
+            'cp1252' => "\x91smart quotes\x92"
+          }
+
+          normalized_json = Invoca::Utils::GuaranteedUTF8String.normalize_all_strings(json_doc,
+                                                                                      normalize_utf16:              true,
+                                                                                      normalize_cp1252:             true,
+                                                                                      normalize_newlines:           true,
+                                                                                      remove_utf8_bom:              true,
+                                                                                      replace_unicode_beyond_ffff:  true)
+
+          assert_equal({
+                         '~' => "✓ laughing cat",
+                         ['~'] => ["â", "~", { "newline" => "\n" }],
+                         'cp1252' => "‘smart quotes’"
+                       }, normalized_json)
+        end
+      end
     end
 
     context 'constructor' do

data/test/unit/hash_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/invoca/utils/hash.rb'
+require_relative '../test_helper'
+
+class HashTest < Minitest::Test
+
+  context 'select_hash' do
+    should 'return a hash containing key/values identified by the block' do
+      assert_equal({ 1 => 2, 3 => 4 }, { 1 => 2, 3 => 4, 6 => 5 }.select_hash { |key, value| key < value })
+    end
+
+    should 'handle blocks that only check values' do
+      assert_equal({ 3 => 4, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 }.select_hash { |value| value != 2 })
+    end
+  end
+
+  context 'map_hash' do
+    should 'return a hash containing values updated by the block' do
+      assert_equal({ 1 => true, 3 => true, 6 => false }, { 1 => 2, 3 => 4, 6 => 5 }.map_hash { |key, value| key < value })
+    end
+
+    should 'handle blocks that only receive values' do
+      assert_equal({ 1 => 4, 3 => 8, 6 => 10 }, { 1 => 2, 3 => 4, 6 => 5 }.map_hash { |value| value * 2 })
+    end
+  end
+
+  context 'partition_hash' do
+    should 'return two hashes, the first contains the pairs with matching keys, the second contains the rest' do
+      assert_equal([{ 1 => 2, 3 => 4 }, { 6 => 5 }], { 1 => 2, 3 => 4, 6 => 5 }.partition_hash([1, 3]))
+    end
+
+    should 'return two hashes, the first contains the pairs with identified by the block, the second contains the rest' do
+      assert_equal([{ 1 => 2, 3 => 4 }, { 6 => 5 }], { 1 => 2, 3 => 4, 6 => 5 }.partition_hash { |key, value| key < value })
+    end
+
+    should 'handle no matches' do
+      assert_equal([{}, { 1 => 2, 3 => 4, 6 => 5 }], { 1 => 2, 3 => 4, 6 => 5 }.partition_hash([100]))
+    end
+
+    should 'handle all matches' do
+      assert_equal([{ 1 => 2, 3 => 4, 6 => 5 }, {}], { 1 => 2, 3 => 4, 6 => 5 }.partition_hash { |_key, _value| true })
+    end
+  end
+
+  context '- operator' do
+    should 'return a hash with pairs removed that match the keys in rhs array' do
+      assert_equal({ 3 => 4 }, { 1 => 2, 3 => 4, 6 => 5 } - [1, 6])
+    end
+
+    should 'handle empty rhs array' do
+      assert_equal({ 1 => 2, 3 => 4, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 } - [])
+    end
+
+    should 'handle no matches in rhs array' do
+      assert_equal({ 1 => 2, 3 => 4, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 } - [100, 600])
+    end
+
+    should 'handle all matches in rhs array' do
+      assert_equal({}, { 1 => 2, 3 => 4, 6 => 5 } - [1, 3, 6])
+    end
+  end
+
+  context '& operator' do
+    should 'return a hash with pairs removed that do NOT match the keys in rhs array' do
+      assert_equal({ 1 => 2, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 } & [1, 6])
+    end
+
+    should 'handle empty rhs array' do
+      assert_equal({}, { 1 => 2, 3 => 4, 6 => 5 } & [])
+    end
+
+    should 'handle no matches in rhs array' do
+      assert_equal({}, { 1 => 2, 3 => 4, 6 => 5 } & [100, 600])
+    end
+
+    should 'handle all matches in rhs array' do
+      assert_equal({ 1 => 2, 3 => 4, 6 => 5 }, { 1 => 2, 3 => 4, 6 => 5 } & [1, 3, 6])
+    end
+  end
+end

data/test/unit/hash_with_indifferent_access_test.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require_relative '../../lib/invoca/utils/hash_with_indifferent_access.rb'
+require_relative '../test_helper'
+
+class HashWithIndifferentAccessTest < Minitest::Test
+
+  context 'partition_hash' do
+    setup do
+      @hash_to_test = HashWithIndifferentAccess.new('one' => 2, :three => 4, 'six' => 5)
+    end
+
+    should 'return two hashes, the first contains the pairs with matching keys, the second contains the rest' do
+      assert_equal([{ 'one' => 2, 'three' => 4 }, { 'six' => 5 }], @hash_to_test.partition_hash(['one', 'three']))
+    end
+
+    should 'return two hashes, the first contains the pairs with identified by the block, the second contains the rest' do
+      assert_equal([{ 'one' => 2, 'three' => 4 }, { 'six' => 5 }], @hash_to_test.partition_hash { |key, _value| ['one', 'three'].include?(key) })
+    end
+
+    should 'handle no matches' do
+      assert_equal([{}, @hash_to_test], @hash_to_test.partition_hash([:not_found]))
+    end
+
+    should 'handle all matches' do
+      assert_equal([@hash_to_test, {}], @hash_to_test.partition_hash { |_key, _value| true })
+    end
+
+    should 'handle symbols for key matching' do
+      assert_equal([{ 'one' => 2, 'three' => 4 }, { 'six' => 5 }], @hash_to_test.partition_hash([:one, :three]))
+    end
+
+    should 'return HashWithIndifferentAccess objects' do
+      matched, unmatched = @hash_to_test.partition_hash([:one, :three])
+      assert(matched.is_a?(HashWithIndifferentAccess))
+      assert(unmatched.is_a?(HashWithIndifferentAccess))
+    end
+  end
+
+  context '- operator' do
+    setup do
+      @hash_to_test = HashWithIndifferentAccess.new('one' => 2, :three => 4, 'six' => 5)
+    end
+
+    should 'return a hash with pairs removed that match the keys in rhs array' do
+      assert_equal({ 'three' => 4 }, @hash_to_test - ['one', 'six'])
+    end
+
+    should 'handle empty rhs array' do
+      assert_equal(@hash_to_test, @hash_to_test - [])
+    end
+
+    should 'handle no matches in rhs array' do
+      assert_equal(@hash_to_test, @hash_to_test - ['100', '600'])
+    end
+
+    should 'handle all matches in rhs array' do
+      assert_equal({}, @hash_to_test - ['one', 'three', 'six'])
+    end
+
+    should 'handle symbols for key matching' do
+      assert_equal({ 'six' => 5 }, @hash_to_test - [:one, :three])
+    end
+
+    should 'return HashWithIndifferentAccess object' do
+      assert((@hash_to_test - [:one, :three]).is_a?(HashWithIndifferentAccess))
+    end
+  end
+
+  context '& operator' do
+    setup do
+      @hash_to_test = HashWithIndifferentAccess.new('one' => 2, :three => 4, 'six' => 5)
+    end
+
+    should 'return a hash with pairs removed that do NOT match the keys in rhs array' do
+      assert_equal({ 'one' => 2, 'six' => 5 }, @hash_to_test & ['one', 'six'])
+    end
+
+    should 'handle empty rhs array' do
+      assert_equal({}, @hash_to_test & [])
+    end
+
+    should 'handle no matches in rhs array' do
+      assert_equal({}, @hash_to_test & ['100', '600'])
+    end
+
+    should 'handle all matches in rhs array' do
+      assert_equal(@hash_to_test, @hash_to_test & ['one', 'three', 'six'])
+    end
+
+    should 'handle symbols for key matching' do
+      assert_equal({ 'one' => 2, 'three' => 4 }, @hash_to_test & [:one, :three])
+    end
+
+    should 'return HashWithIndifferentAccess object' do
+      assert((@hash_to_test & [:one, :three]).is_a?(HashWithIndifferentAccess))
+    end
+  end
+end

data/test/unit/module_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# must require active_support's alias_method_chain first, to ensure that our module monkey patches it
+require 'active_support/core_ext/module/aliasing'
+require_relative '../../lib/invoca/utils/module.rb'
+require_relative '../test_helper'
+
+class ModuleTest < Minitest::Test
+  class NumberFun
+    def self.around_filter(around_method, method_names)
+      method_names.each do |meth|
+        define_method("#{meth}_with_around_filter") do |*args|
+          send(around_method, *args) do |*ar_args|
+            send("#{meth}_without_around_filter", *ar_args)
+          end
+        end
+
+        alias_method_chain meth, :around_filter
+      end
+    end
+
+    def increment_filter(num)
+      yield(num + 1)
+    end
+
+    def number_printer(num)
+      num
+    end
+
+    around_filter :increment_filter, [:number_printer]
+    around_filter :increment_filter, [:number_printer]
+  end
+
+  context 'alias_method_chain' do
+    should 'not cause infinite recursion when double aliasing the same method' do
+      assert_equal(4, NumberFun.new.number_printer(3))
+    end
+  end
+end

data/test/unit/multi_sender_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/invoca/utils/multi_sender.rb'
+require_relative '../test_helper'
+
+class MultiSenderTest < Minitest::Test
+  # create enumerable class for testing
+  class LinkedList
+    include Enumerable
+
+    def initialize(head, tail = nil)
+      @head, @tail = head, tail
+    end
+
+    def <<(item)
+      LinkedList.new(item, self)
+    end
+
+    def inspect
+      [@head, @tail].inspect
+    end
+
+    def each(&block)
+      if block_given?
+        block.call(@head)
+        @tail&.each(&block)
+      else
+        to_enum(:each)
+      end
+    end
+  end
+
+  context 'MultiSender' do
+    context 'with custom Enumerable' do
+      setup do
+        linked_list = LinkedList.new('some') << 'short' << 'words'
+        @multi_sender = Invoca::Utils::MultiSender.new(linked_list, :map)
+      end
+
+      should 'call the same method on each item in an Enumerable and return the results as an array' do
+        assert_equal([5, 5, 4], @multi_sender.length)
+      end
+
+      should 'handle methods with arguments' do
+        assert_equal(['or', 'ho', 'om'], @multi_sender.slice(1, 2))
+      end
+    end
+
+    context 'with built-in Array' do
+      should 'call the same method on each item in an Array and return the results as an array' do
+        multi_sender = Invoca::Utils::MultiSender.new(['some', 'short', 'words'], :map)
+        assert_equal([4, 5, 5], multi_sender.length)
+      end
+    end
+  end
+end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: invoca-utils
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.4.1
 platform: ruby
 authors:
 - Invoca development
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-16 00:00:00.000000000 Z
+date: 2020-06-17 00:00:00.000000000 Z
 dependencies: []
-description: A public collection of helpers used in multiple projects
+description: 
 email:
 - development@invoca.com
 executables: []
@@ -18,8 +18,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".jenkins/Jenkinsfile"
+- ".jenkins/ruby_build_pod.yml"
 - ".rubocop.yml"
 - ".ruby-version"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -27,18 +30,32 @@ files:
 - Rakefile
 - invoca-utils.gemspec
 - lib/invoca/utils.rb
+- lib/invoca/utils/array.rb
 - lib/invoca/utils/diff.rb
+- lib/invoca/utils/enumerable.rb
+- lib/invoca/utils/exceptions.rb
 - lib/invoca/utils/guaranteed_utf8_string.rb
+- lib/invoca/utils/hash.rb
+- lib/invoca/utils/hash_with_indifferent_access.rb
 - lib/invoca/utils/http.rb
 - lib/invoca/utils/map_compact.rb
 - lib/invoca/utils/min_max.rb
+- lib/invoca/utils/module.rb
+- lib/invoca/utils/multi_sender.rb
 - lib/invoca/utils/stable_sort.rb
 - lib/invoca/utils/time.rb
 - lib/invoca/utils/version.rb
 - test/helpers/constant_overrides.rb
 - test/test_helper.rb
+- test/unit/array_test.rb
+- test/unit/enumerable_test.rb
+- test/unit/exceptions_test.rb
 - test/unit/guaranteed_utf8_string_test.rb
+- test/unit/hash_test.rb
+- test/unit/hash_with_indifferent_access_test.rb
 - test/unit/map_compact_test.rb
+- test/unit/module_test.rb
+- test/unit/multi_sender_test.rb
 - test/unit/stable_sort_test.rb
 - test/unit/time_calculations_test.rb
 - test/unit/utils_test.rb
@@ -62,16 +79,22 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: A public collection of helpers used in multiple projects
 test_files:
 - test/helpers/constant_overrides.rb
 - test/test_helper.rb
+- test/unit/array_test.rb
+- test/unit/enumerable_test.rb
+- test/unit/exceptions_test.rb
 - test/unit/guaranteed_utf8_string_test.rb
+- test/unit/hash_test.rb
+- test/unit/hash_with_indifferent_access_test.rb
 - test/unit/map_compact_test.rb
+- test/unit/module_test.rb
+- test/unit/multi_sender_test.rb
 - test/unit/stable_sort_test.rb
 - test/unit/time_calculations_test.rb
 - test/unit/utils_test.rb