mug 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa82b3dcf328caf01f65d84a51ac4bdfdc186c91648f5b7843aa34531c4877ad
-  data.tar.gz: a33c8edf6d0d3359c9b7ce9592bee55f2cef5b2955e74f2c71913048bbe6d61b
+  metadata.gz: c8175797f8f16b61b543159d47d39249fc260a6389a2d83825e5bbe3525bd33c
+  data.tar.gz: 3d4a5d28f5e59c652bd0267de97db75d155861e6c6467446bd453132c40be9b7
 SHA512:
-  metadata.gz: 77ab2daffae07f208c90b692afafd8287850fc57ddeade9fb363d517ff7844a921695aee7af8522b3dc66edc09540b408e1f9c0a20d345563cf23981f6cf7806
-  data.tar.gz: 5463372e8cb36dd4b92780354a08131b9fda6d5d34857c04dfc5e029a26b66682064b888c4b4e0b4a21b1b4ea7f1e2b7823091e80f8ec0ecba99bf1c47b7669a
+  metadata.gz: e0686f5a34f70143e992e2baec18eb45f53a20cba5912aa4a89d4dc95e8bb2f26c92abdde86c9ac8ea6a7f6ce817354a211dfa6083613bf88d6e3b1479d8eb8b
+  data.tar.gz: cb47764028f427e09864ee1d5bd1466a9e2221a07e1853b20134e1d1dbfbb01014003feabb5f641cf9aac22394b25b489838cfae832fd96c85e3c8e0b1b66171

data/lib/mug.rb

@@ -2,7 +2,6 @@
 require_relative 'mug/affix'
 require_relative 'mug/alias'
 require_relative 'mug/and-or'
-require_relative 'mug/any-and-all'
 require_relative 'mug/apply'
 require_relative 'mug/array/delete_all'
 require_relative 'mug/array/extend'
@@ -12,7 +11,7 @@ require_relative 'mug/array/to_proc'
 require_relative 'mug/bool'
 require_relative 'mug/bittest'
 require_relative 'mug/clamp'
-require_relative 'mug/counts'
+require_relative 'mug/enumerable'
 require_relative 'mug/fragile-method-chain'
 require_relative 'mug/hash/map'
 require_relative 'mug/hash/merge'

data/lib/mug/any-and-all.rb

@@ -1,38 +1,3 @@
 
-module Enumerable
-
-  #
-  # Passes each element of the collection to the given block. The method returns `true` if the
-  # block contains elements that never return `false` or `nil`. If the block is not given, Ruby
-  # adds an implicit block of `{ |obj| obj }` which will cause `any_and_all?` to return `true`
-  # when none of the collection members are `false` or `nil`.
-  #
-  def any_and_all? &block
-    block ||= proc {|obj| obj }
-
-    result = false
-    each do |x|
-      return false unless block[x]
-      result = true
-    end
-    result
-  end
-
-end
-
-=begin
-Copyright (c) 2016, Matthew Kerwin <matthew@kerwin.net.au>
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-=end
+require_relative 'enumerable/any-and-all'
 

data/lib/mug/counts.rb

@@ -1,34 +1,3 @@
 
-module Enumerable
-
-  #
-  # Returns a hash of item=>count showing how many
-  # of each +item+ are in this Enumerable.
-  #
-  def counts &block
-    return counts_by(&block) if block_given?
-    hsh = Hash.new{|h,k| h[k] = 0 }
-    each do |k|
-      hsh[k] += 1
-    end
-    hsh
-  end
-
-  #
-  # Passes each element in turn to the block, and returns a
-  # hash of result=>count.
-  #
-  # If no block is given, an enumerator is returned.
-  #
-  def counts_by &block
-    return enum_for(:counts_by) unless block_given?
-    hsh = Hash.new{|h,k| h[k] = 0 }
-    each do |j|
-      k = yield j
-      hsh[k] += 1
-    end
-    hsh
-  end
-
-end
+require_relative 'enumerable/counts'
 

data/lib/mug/enumerable.rb

@@ -0,0 +1,5 @@
+
+require_relative 'enumerable/any-and-all'
+require_relative 'enumerable/counts'
+require_relative 'enumerable/hash-like'
+

data/lib/mug/enumerable/any-and-all.rb

@@ -0,0 +1,38 @@
+
+module Enumerable
+
+  #
+  # Passes each element of the collection to the given block. The method returns `true` if the
+  # block contains elements that never return `false` or `nil`. If the block is not given, Ruby
+  # adds an implicit block of `{ |obj| obj }` which will cause `any_and_all?` to return `true`
+  # when none of the collection members are `false` or `nil`.
+  #
+  def any_and_all? &block
+    block ||= proc {|obj| obj }
+
+    result = false
+    each do |x|
+      return false unless block[x]
+      result = true
+    end
+    result
+  end
+
+end
+
+=begin
+Copyright (c) 2018, Matthew Kerwin <matthew@kerwin.net.au>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+=end
+

data/lib/mug/enumerable/counts.rb

@@ -0,0 +1,50 @@
+
+module Enumerable
+
+  #
+  # Returns a hash of item=>count showing how many
+  # of each +item+ are in this Enumerable.
+  #
+  def counts &block
+    return counts_by(&block) if block_given?
+    hsh = Hash.new{|h,k| h[k] = 0 }
+    each do |k|
+      hsh[k] += 1
+    end
+    hsh
+  end
+
+  #
+  # Passes each element in turn to the block, and returns a
+  # hash of result=>count.
+  #
+  # If no block is given, an enumerator is returned.
+  #
+  def counts_by &block
+    return enum_for(:counts_by) unless block_given?
+    hsh = Hash.new{|h,k| h[k] = 0 }
+    each do |j|
+      k = yield j
+      hsh[k] += 1
+    end
+    hsh
+  end
+
+end
+
+=begin
+Copyright (c) 2018, Matthew Kerwin <matthew@kerwin.net.au>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+=end
+

data/lib/mug/enumerable/hash-like.rb

@@ -0,0 +1,244 @@
+
+module Enumerable
+
+  ##
+  # Calls +block+ once for each key in the enum, passing the key-value pair as parameters.
+  # If no block is given, an enumerator is returned instead.
+  #
+  # @call-seq each_pair {| key, value | block } -> hsh
+  # @call-seq each_pair -> an_enumerator
+  #
+  def each_pair
+    return enum_for(:each_pair) unless block_given?
+    each_with_index {|e,i| yield i, e }
+  end
+
+  ##
+  # Calls +block+ once for each key in the enum, passing the key as a parameter.
+  # If no block is given, an enumerator is returned instead.
+  #
+  # @call-seq each_key {| key | block } -> hsh
+  # @call-seq each_key -> an_enumerator
+  #
+  def each_key
+    return enum_for(:each_key) unless block_given?
+
+    # FIXME
+    each_with_index {|_,i| yield i }
+  end
+
+  alias each_value each_entry
+
+  ##
+  # Returns a value from the enum for the given key. If the key can't be
+  # found, there are several options: With no other arguments, it will
+  # raise a +KeyError+ exception; if +default+ is given, then that will
+  # be returned; if the optional code block is specified, then that will
+  # be run and its result returned.
+  #
+  # @call-seq fetch(key [, default] ) -> obj
+  # @call-seq fetch(key) { |key| block } -> obj
+  #
+  def fetch *args
+    raise ArgumentError, "incorrect number of arguments (#{args.length} for 1..2)" if args.length < 1 || args.length > 2
+    key, default = *args
+
+    each_pair do |k,v|
+      return v if k == key
+    end
+    if args.length > 1
+      return default
+    elsif block_given?
+      yield key
+    else
+      raise KeyError, 'key not found'
+    end
+  end
+
+  ##
+  # Returns an array containing the values associated with the given keys
+  # but also raises +KeyError+ when one of keys can't be found.
+  # Also see +#values_at+ and +#fetch+.
+  #
+  # @call-seq fetch_values(key, ...) -> array
+  # @call-seq fetch_values(key, ...) { |key| block } -> array
+  #
+  def fetch_values *keys
+    key_map = {}
+    keys.each_with_index do |key, index|
+      key_map[key] ||= []
+      key_map[key] << index
+    end
+
+    remain = keys.length
+    result = [nil] * keys.length
+    define = [nil] * keys.length
+
+    each_pair do |k,v|
+      break if remain < 1
+
+      key_indices = key_map[k]
+      if key_indices
+        key_indices.each do |key_index|
+          result[key_index] = v
+          define[key_index] = true
+          remain -= 1
+        end
+      end
+    end
+
+    if remain > 0
+      if block_given?
+        define.each_with_index do |isdef, index|
+          next if isdef
+          result[index] = yield keys[index]
+        end
+      else
+        index = define.index nil
+        raise KeyError, "key not found: #{keys[index].inspect}"
+      end
+    end
+
+    result
+  end
+
+  alias key find_index
+
+  ##
+  # Returns +true+ if the given key is present in this enum.
+  #
+  # @call-seq key?(key) -> true or false
+  #
+  def key? key
+    each_pair.find {|k, _| key == k } && true
+  end
+  alias has_key? key?
+
+  ##
+  # Returns a new array populated with the keys from this enum.
+  #
+  # @call-seq keys -> array
+  #
+  def keys
+    each_with_index.map {|_, index| index }
+  end
+
+  ##
+  # Returns the number of key-value pairs in the hash.
+  #
+  # @call-seq length -> integer
+  #
+  def length
+    reduce(0) {|sum,_| sum + 1 }
+  end
+  alias size length
+
+  ##
+  # Returns true if the given key is present in this enum.
+  #
+  # @call-seq member?(key) -> true or false
+  #
+  def member? key
+    fetch(key, nil) && true
+  end
+
+  ##
+  # Returns a hash containing only the given keys and their values.
+  #
+  # @call-seq slice(*keys) -> a_hash
+  #
+  def slice *keys
+    missing = {}
+    values = fetch_values(*keys) {|key| missing[key] = nil }
+
+    result = {}
+    values.each_with_index do |val, i|
+      key = keys[i]
+      next if missing.key? key
+      next if result.key? key
+      result[key] = val
+    end
+    result
+  end
+
+  ##
+  # Returns a new hash with the results of running the block once for every key.
+  # If no block is given, an enumerator is returned instead.
+  #
+  # @call-seq transform_keys {|key| block } -> new_hash
+  # @call-seq transform_keys -> an_enumerator
+  #
+  def transform_keys
+    return enum_for(:transform_keys) unless block_given?
+    result = {}
+    each_pair do |key, value|
+      newkey = yield key
+      result[newkey] = value
+    end
+    result
+  end
+
+  ##
+  # Returns a new hash with the results of running the block once for every value.
+  # If no block is given, an enumerator is returned instead.
+  #
+  # @call-seq transform_values {|value| block } -> new_hash
+  # @call-seq transform_values -> an_enumerator
+  #
+  def transform_values
+    return enum_for(:transform_values) unless block_given?
+    result = {}
+    each_pair do |key, value|
+      newvalue = yield value
+      result[key] = newvalue
+    end
+    result
+  end
+
+  ##
+  # Returns +true+ if the given value is present for some key.
+  #
+  # @call-seq value?(value) -> true or false
+  #
+  def value? value
+    include? value
+  end
+  alias has_value? value?
+
+  ##
+  # Returns a new array populated with the values from this enum.
+  #
+  # @call-seq values -> array
+  #
+  def values
+    to_a
+  end
+
+  ##
+  # Return an array containing the values associated with the given keys.
+  #
+  # @call-seq values_at(key, ...) -> array
+  #
+  def values_at *keys
+    fetch_values(*keys) {|key| nil }
+  end
+
+end
+
+
+=begin
+Copyright (c) 2018, Matthew Kerwin <matthew@kerwin.net.au>
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+=end
+

data/test/test-any-and-all.rb

@@ -1,7 +1,7 @@
 require 'test/unit'
 $VERBOSE = true
 
-require_relative '../lib/mug/any-and-all'
+require_relative '../lib/mug/enumerable/any-and-all'
 class Test_any_and_all < Test::Unit::TestCase
   def test_any_and_all__block
     b = proc {|o| o > 1 }

data/test/test-counts.rb

@@ -1,8 +1,8 @@
 require 'test/unit'
 $VERBOSE = true
 
-require_relative '../lib/mug/counts'
-class Test_hashmap < Test::Unit::TestCase
+require_relative '../lib/mug/enumerable/counts'
+class Test_counts < Test::Unit::TestCase
   def test_counts
     a = %w(a b b c c c)
     c = {'a'=>1, 'b'=>2, 'c'=>3}

data/test/test-enumerable-hash-like.rb

@@ -0,0 +1,245 @@
+require 'test/unit'
+$VERBOSE = true
+
+class HashLikeEnum
+  def each
+    return enum_for(:each) unless block_given?
+    yield 'a'
+    yield 'b'
+    yield 'c'
+    yield 'd'
+  end
+  include Enumerable
+end
+
+require_relative '../lib/mug/enumerable/hash-like'
+class Test_hashlike < Test::Unit::TestCase
+  def test__each_pair__block
+    my_enum = HashLikeEnum.new
+    expect = [[0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']]
+
+    my_enum.each_pair do |key, value|
+      exp = expect.shift
+      assert_equal(exp, [key, value])
+    end
+  end
+
+  def test__each_pair
+    my_enum = HashLikeEnum.new
+    expect = [[0, 'a'], [1, 'b'], [2, 'c'], [3, 'd']]
+
+    enm = my_enum.each_pair
+
+    enm.each do |key, value|
+      exp = expect.shift
+      assert_equal(exp, [key, value])
+    end
+  end
+
+  def test__each_key__block
+    my_enum = HashLikeEnum.new
+    expect = [0, 1, 2, 3]
+
+    my_enum.each_key do |key|
+      exp = expect.shift
+      assert_equal(exp, key)
+    end
+  end
+
+  def test__each_key
+    my_enum = HashLikeEnum.new
+    expect = [0, 1, 2, 3]
+
+    enm = my_enum.each_key
+
+    enm.each do |key|
+      exp = expect.shift
+      assert_equal(exp, key)
+    end
+  end
+
+  def test__each_value__block
+    my_enum = HashLikeEnum.new
+    expect = %w[a b c d]
+
+    my_enum.each_value do |value|
+      exp = expect.shift
+      assert_equal(exp, value)
+    end
+  end
+
+  def test__each_value
+    my_enum = HashLikeEnum.new
+    expect = %w[a b c d]
+
+    enm = my_enum.each_value
+
+    enm.each do |value|
+      exp = expect.shift
+      assert_equal(exp, value)
+    end
+  end
+
+  def test__fetch
+    my_enum = HashLikeEnum.new
+
+    assert_raise(ArgumentError) { my_enum.fetch }
+
+    assert_equal('a', my_enum.fetch(0))
+    assert_equal('d', my_enum.fetch(3))
+    assert_raise(KeyError) { my_enum.fetch(5) }
+    assert_raise(KeyError) { my_enum.fetch(-1) }
+    assert_raise(KeyError) { my_enum.fetch('not a number') }
+  end
+
+  def test__fetch__default
+    my_enum = HashLikeEnum.new
+    default = 'z'
+
+    assert_equal('a', my_enum.fetch(0, default))
+    assert_equal('d', my_enum.fetch(3, default))
+    assert_equal(default, my_enum.fetch(5, default))
+    assert_equal(default, my_enum.fetch(-1, default))
+    assert_equal(default, my_enum.fetch('not a number', default))
+  end
+
+  def test__fetch__block
+    my_enum = HashLikeEnum.new
+
+    block = proc {|key| key }
+
+    assert_equal('a', my_enum.fetch(0, &block))
+    assert_equal('d', my_enum.fetch(3, &block))
+    assert_equal(5, my_enum.fetch(5, &block))
+    assert_equal(-1, my_enum.fetch(-1, &block))
+    assert_equal('not a number', my_enum.fetch('not a number', &block))
+  end
+
+  def test__fetch__default_block
+    my_enum = HashLikeEnum.new
+    default = 'z'
+
+    block = proc {|key| key }
+
+    assert_equal('a', my_enum.fetch(0, default, &block))
+    assert_equal('d', my_enum.fetch(3, default, &block))
+    assert_equal(default, my_enum.fetch(5, default, &block))
+    assert_equal(default, my_enum.fetch(-1, default, &block))
+    assert_equal(default, my_enum.fetch('not a number', default, &block))
+  end
+
+  def test__fetch_values
+    my_enum = HashLikeEnum.new
+
+    assert_equal(%w[a d], my_enum.fetch_values(0, 3))
+    assert_equal(%w[a d a d], my_enum.fetch_values(0, 3, 0, 3))
+    assert_raise(KeyError) { my_enum.fetch_values(5) }
+    assert_raise(KeyError) { my_enum.fetch_values(0, 3, 5) }
+  end
+
+  def test__fetch_values__block
+    my_enum = HashLikeEnum.new
+
+    block = proc {|key| key }
+
+    assert_equal(%w[a d], my_enum.fetch_values(0, 3, &block))
+    assert_equal(%w[a d a d], my_enum.fetch_values(0, 3, 0, 3, &block))
+    assert_equal([5], my_enum.fetch_values(5, &block))
+    assert_equal(['a', 'd', 5], my_enum.fetch_values(0, 3, 5, &block))
+  end
+
+  def test__key
+    my_enum = HashLikeEnum.new
+
+    assert_equal(0, my_enum.key('a'))
+    assert_equal(3, my_enum.key('d'))
+    assert_nil(my_enum.key('missing'))
+  end
+
+  def test__keys
+    my_enum = HashLikeEnum.new
+    expect = [0, 1, 2, 3]
+
+    assert_equal(expect, my_enum.keys)
+  end
+
+  def test__length
+    my_enum = HashLikeEnum.new
+    expect = 4
+
+    assert_equal(expect, my_enum.length)
+  end
+
+  def test__member?
+    my_enum = HashLikeEnum.new
+
+    assert(my_enum.member?(0))
+    assert(my_enum.member?(3))
+    assert(!my_enum.member?(5))
+    assert(!my_enum.member?(-1))
+    assert(!my_enum.member?('not a number'))
+  end
+
+  def test__slice
+    my_enum = HashLikeEnum.new
+
+    assert_equal({0=>'a', 3=>'d'}, my_enum.slice(0, 3))
+    assert_equal({0=>'a', 3=>'d'}, my_enum.slice(0, 3, 0))
+    assert_equal({0=>'a', 3=>'d'}, my_enum.slice(0, 3, 5))
+    assert_equal({0=>'a', 3=>'d'}, my_enum.slice(0, 3, -1))
+    assert_equal({0=>'a', 3=>'d'}, my_enum.slice(0, 3, 'not a number'))
+    assert_equal({}, my_enum.slice())
+  end
+
+  def test__transform_keys
+    my_enum = HashLikeEnum.new
+
+    block = proc {|key| "_#{key}_" }
+
+    enm = my_enum.transform_keys
+    assert_equal({'_0_'=>'a', '_1_'=>'b', '_2_'=>'c', '_3_'=>'d'}, enm.each(&block))
+  end
+
+  def test__transform_keys__block
+    my_enum = HashLikeEnum.new
+
+    block = proc {|key| "_#{key}_" }
+
+    assert_equal({'_0_'=>'a', '_1_'=>'b', '_2_'=>'c', '_3_'=>'d'}, my_enum.transform_keys(&block))
+  end
+
+  def test__transform_values
+    my_enum = HashLikeEnum.new
+
+    block = proc {|value| value.upcase }
+
+    enm = my_enum.transform_values
+    assert_equal({0=>'A', 1=>'B', 2=>'C', 3=>'D'}, enm.each(&block))
+  end
+
+  def test__transform_values__block
+    my_enum = HashLikeEnum.new
+
+    block = proc {|value| value.upcase }
+
+    assert_equal({0=>'A', 1=>'B', 2=>'C', 3=>'D'}, my_enum.transform_values(&block))
+  end
+
+  def test__values
+    my_enum = HashLikeEnum.new
+
+    assert_equal(%w[a b c d], my_enum.values)
+  end
+
+  def test__values_at
+    my_enum = HashLikeEnum.new
+
+    assert_equal(%w[a d], my_enum.values_at(0, 3))
+    assert_equal(%w[a d a], my_enum.values_at(0, 3, 0))
+    assert_equal(['a',nil,'d'], my_enum.values_at(0, 5, 3))
+    assert_equal(['a',nil,'d'], my_enum.values_at(0, -1, 3))
+    assert_equal(['a',nil,'d'], my_enum.values_at(0, 'not a number', 3))
+    assert_equal([], my_enum.values_at())
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mug
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Matthew Kerwin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-05 00:00:00.000000000 Z
+date: 2018-03-12 00:00:00.000000000 Z
 dependencies: []
 description: |
   == MUG: Matty's Ultimate Gem
@@ -38,6 +38,10 @@ files:
 - lib/mug/bool.rb
 - lib/mug/clamp.rb
 - lib/mug/counts.rb
+- lib/mug/enumerable.rb
+- lib/mug/enumerable/any-and-all.rb
+- lib/mug/enumerable/counts.rb
+- lib/mug/enumerable/hash-like.rb
 - lib/mug/fragile-method-chain.rb
 - lib/mug/hash.rb
 - lib/mug/hash/map.rb
@@ -78,6 +82,7 @@ files:
 - test/test-bool.rb
 - test/test-clamp.rb
 - test/test-counts.rb
+- test/test-enumerable-hash-like.rb
 - test/test-fragile-method-chain.rb
 - test/test-hashmap.rb
 - test/test-hashmerge.rb
@@ -121,6 +126,7 @@ signing_key:
 specification_version: 4
 summary: 'MUG: Matty''s Ultimate Gem'
 test_files:
+- test/test-enumerable-hash-like.rb
 - test/test-clamp.rb
 - test/test-array-delete_all.rb
 - test/test-rexproc.rb