invoca-utils 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d869f76e3859bafbdd5f0d85d0279d1fb5fc2f59abe6ef41379c48cf5e96f45
-  data.tar.gz: 2c230a4b5f721b09ed38b31c69c9214ce168c61554a2af470f0dceb318bee17b
+  metadata.gz: 926143286cf40283408cd86732347339453d12a671c2e1539f01e391cef84ed4
+  data.tar.gz: b4114b43131585610f6e875680895e1be15fe68e164a0a8904ddec46b59e58cf
 SHA512:
-  metadata.gz: f5864c29abc79c5ccde2e619d10eb66e1e744b4eeebb27bf67da225af51c6b07abcf0795b3d951565d42075f09b6d43953f403bc08f63431cb47fee3cf241c65
-  data.tar.gz: '018ffc3b0084997d5ae2a89a846c5fb00bdda5f53602e026efa63a9e0f20515926a3747a7bbd68792cd78ab2f9171162ddfce38366ad39afe7996537c7c35d82'
+  metadata.gz: 50a6cf86a1547385b1b7dabfce31f4a89d0156f872f7dde7b6e179afd6373f8b56cc6e4bfea3b383af02aaabb6567a096d4dfe9250a8e639a0f02c3d0535455f
+  data.tar.gz: 2bcfc2fa9de854a2f78ba03a5bd9814fc921c9ab668ca0660491b14679e81536a9e4c61cb6e4b8f00f88ddb609a891956f02094de64e48efbe0411fdc4afbeff

data/CHANGELOG.md

@@ -4,9 +4,18 @@ 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.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.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

@@ -5,6 +5,7 @@ source 'https://rubygems.org'
 gemspec
 
 group :development do
+  gem 'activesupport', '~> 4.2'
   gem 'minitest'
   gem 'minitest-reporters'
   gem 'pry'

data/Gemfile.lock

@@ -1,26 +1,26 @@
 PATH
   remote: .
   specs:
-    invoca-utils (0.2.0)
+    invoca-utils (0.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (5.1.4)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
+    activesupport (4.2.11.1)
       i18n (~> 0.7)
       minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
       tzinfo (~> 1.1)
     ansi (1.5.0)
     builder (3.2.4)
     coderay (1.1.2)
-    concurrent-ruby (1.0.5)
+    concurrent-ruby (1.1.6)
     hoe (3.22.1)
       rake (>= 0.8, < 15.0)
-    i18n (0.9.1)
+    i18n (0.9.5)
       concurrent-ruby (~> 1.0)
     method_source (0.9.0)
-    minitest (5.11.1)
+    minitest (5.14.0)
     minitest-reporters (1.1.14)
       ansi
       builder
@@ -42,13 +42,14 @@ GEM
     test-unit (1.2.3)
       hoe (>= 1.5.1)
     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
   minitest-reporters

data/lib/invoca/utils.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
+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"

data/lib/invoca/utils/array.rb

@@ -3,18 +3,16 @@
 require_relative './multi_sender'
 
 # Invoca ::Array extensions
-module Invoca
-  module Utils
-    module ArrayMultiply
-      def *(rhs = nil)
-        if rhs
-          super
-        else
-          Invoca::Utils::MultiSender.new(self, :map)
-        end
-      end
+# 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
-
-Array.prepend(Invoca::Utils::ArrayMultiply)

data/lib/invoca/utils/enumerable.rb

@@ -4,6 +4,21 @@ 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
@@ -12,6 +27,14 @@ module Enumerable
     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

data/lib/invoca/utils/hash.rb

@@ -0,0 +1,44 @@
+# 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/version.rb

@@ -2,6 +2,6 @@
 
 module Invoca
   module Utils
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

data/test/unit/enumerable_test.rb

@@ -6,6 +6,44 @@ 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] })

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: invoca-utils
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Invoca development
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-27 00:00:00.000000000 Z
+date: 2020-04-29 00:00:00.000000000 Z
 dependencies: []
 description: A public collection of helpers used in multiple projects
 email:
@@ -34,9 +34,12 @@ files:
 - lib/invoca/utils/diff.rb
 - lib/invoca/utils/enumerable.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
@@ -46,7 +49,10 @@ files:
 - test/unit/array_test.rb
 - test/unit/enumerable_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
@@ -81,7 +87,10 @@ test_files:
 - test/unit/array_test.rb
 - test/unit/enumerable_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