rekey 4.0.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9fd354b9d3c1d9586254cada81be1e6bb9727a4a
-  data.tar.gz: 35a6a2235d235543d2ce42cd483f98ba8ea3da38
+SHA256:
+  metadata.gz: 2fa7a26ea0c5de294ea7b5b87c72d9bfb1dfe60bd4aed34068712d0e751dab4d
+  data.tar.gz: d4021c41d1147df578cb411224c53adcef870b1484e45c432c83f9312b81a089
 SHA512:
-  metadata.gz: f3dba9ce015ac3bd8cb5c6b0e9c1f887c2127453649e2d0357e52d710ddc67970a8ae2747d3b1686198ed29533b66c3445df3ef227d69b39c6666c075b51301c
-  data.tar.gz: b9b139e019b4587f06dd0c1a1fed7e7fb9e7bd78c72af91cdb2202a8015612c1f268e10b121cfcb23e12ac8160e2b10f83368b55cf6d6e400cb8048bbc81e62e
+  metadata.gz: af81ef145ff59e27ac19c720f44f4976c69df570c2d19d7b711f134906df651c8e202798ab9429644b59dba4e4f47d0cd367db90a07b8838a4540d522cfd8a19
+  data.tar.gz: '0986dbde9b4e19dcc4f4b07ce619396a335b990258107ce0b5314844aa0a2e5d24fe4fd3d43379e9fb7af2fd619a38d6587a8baf708cd4db2ecbcdd3d56a6d52'

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+###  4.2.0  (2026-11-03)
+- drop Ruby 3.0 and 3.1 (end of life); requires Ruby >= 3.2
+- fix: a block with two required args and a splat (`|k, v, *rest|`) gets the key and value instead of the value as `k`
+- fix: a `false` handle passed together with a block raises ArgumentError instead of being ignored
+- feature: a callable (lambda, proc, Method) works as a key or value handle: `users.rekey(:id, ->(u) { u.name.upcase })`. Requires pluckit >= 1.3
+
+###  4.1.0  (2026-04-10)
+- ruby version / gem updates
+
+###  4.0.0  (2018-10-08)
+- 7a49250 better monkey patching tests
+- 9d94818 extend self
+- 574461c clean up arity handling, expand tests
+- 4b85ea6 require a key handle or block...for a nil key operation, use PluckIt
+- d6cba35 fix unit test requires
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Daniel Pepper
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,118 @@
+Rekey
+======
+![Gem](https://img.shields.io/gem/dt/rekey?style=plastic)
+[![codecov](https://codecov.io/gh/dpep/rekey_rb/branch/main/graph/badge.svg?token=Z6W48XUEQD)](https://codecov.io/gh/dpep/rekey_rb)
+
+Turn an Enumerable into a Hash, with derived keys and values.
+
+```ruby
+require "rekey"
+
+rows = [
+  { id: 1, name: "alice" },
+  { id: 2, name: "bob" },
+]
+
+rows.rekey(:id)
+# => {1 => {id: 1, name: "alice"}, 2 => {id: 2, name: "bob"}}
+
+rows.rekey(:id, :name)
+# => {1 => "alice", 2 => "bob"}
+```
+
+#### Install
+```gem install rekey```
+
+
+#### Handles
+`rekey(key_handle, value_handle = nil)`. Without a value handle, each element is its own value.
+
+[pluckit](https://github.com/dpep/pluckit_rb) resolves handles, so a handle can be a Hash key, a method name, an array index, a Range, or a Regexp:
+
+```ruby
+[[1, "a"], [2, "b"]].rekey(0, 1)
+# => {1 => "a", 2 => "b"}
+
+%w[apple banana].rekey(0..2, :length)
+# => {"app" => 5, "ban" => 6}
+
+%w[apple banana].rekey(/^./)
+# => {"a" => "apple", "b" => "banana"}
+```
+
+A callable (lambda, proc, Method) works as either handle:
+
+```ruby
+rows.rekey(:id, ->(r) { r[:name].upcase })
+# => {1 => "ALICE", 2 => "BOB"}
+
+[1, 2].rekey(:itself, 10.method(:*))
+# => {1 => 10, 2 => 20}
+```
+
+
+#### Blocks
+A block computes the key; the element stays the value.
+
+```ruby
+[2, 4, 6].rekey { |v| v / 2 }
+# => {1 => 2, 2 => 4, 3 => 6}
+```
+
+Pass handles or a block, not both. Mixing them raises ArgumentError.
+
+
+#### Hash input
+Handles and one-parameter blocks look at the values. The outer keys are dropped.
+
+```ruby
+users = {
+  x: { id: 1, name: "alice" },
+  y: { id: 2, name: "bob" },
+}
+
+users.rekey(:id, :name)
+# => {1 => "alice", 2 => "bob"}
+```
+
+A block with two required parameters gets the key and value:
+
+```ruby
+{ a: 1 }.rekey { |k, v| "#{k}#{v}" }
+# => {"a1" => 1}
+```
+
+On anything other than a Hash, a two-parameter block raises ArgumentError.
+
+
+#### Duplicate keys
+The last one wins, as with `to_h` and `index_by`.
+
+```ruby
+[{ id: 1, v: "a" }, { id: 1, v: "b" }].rekey(:id, :v)
+# => {1 => "b"}
+```
+
+Watch for a handle that misses. A typo, or `"id"` on symbol-keyed hashes, gives `nil` for every row, so the whole result collapses to one entry:
+
+```ruby
+rows.rekey("id")
+# => {nil => {id: 2, name: "bob"}}
+```
+
+
+#### Without the monkey patch
+`require "rekey"` adds `#rekey` to every Enumerable. To skip the global patch, load the module alone and use the refinement, or call it directly:
+
+```ruby
+require "rekey/rekey"
+
+using Rekey
+rows.rekey(:id)
+
+# or
+Rekey.rekey(rows, :id)
+```
+
+
+----

data/lib/rekey/rekey.rb

@@ -1,11 +1,18 @@
-require 'pluckit/pluck'
+require "pluckit/pluck"
+require "rekey/version"
 
 
 module Rekey
   extend self
 
+  refine Enumerable do
+    def rekey(key_handle = nil, value_handle = nil, &block)
+      Rekey.rekey(self, key_handle, value_handle, &block)
+    end
+  end
+
   def rekey(enumerable, key_handle = nil, value_handle = nil, &block)
-    validate_input key_handle, value_handle, &block
+    validate_input!(key_handle, value_handle, &block)
 
     key_value_fn = if enumerable.respond_to?(:keys)
       proc {|k, v| [k, v]}
@@ -15,29 +22,28 @@ module Rekey
 
     # rekey input
     enumerable.each_with_object({}) do |*args, res|
-      key, value = key_value_fn.call *args
+      key, value = key_value_fn.call(*args)
       new_key = key
       new_value = value
 
       if block
-        if block.arity < 2
+        if required_args(block) < 2
           # block only wants value
-          # arity -1 is a function pointer, eg. &:to_i
-          new_key = block.call value
+          new_key = block.call(value)
         else
           # block wants both key and value
 
           if key_value_fn.arity != 2
             raise ArgumentError.new(
-              'rekey block requests key/value pair but only value available'
+              "rekey block requests key/value pair but only value available"
             )
           end
 
-          new_key = block.call key, value
+          new_key = block.call(key, value)
         end
       else
-        new_key = PluckIt.pluckit value, key_handle
-        new_value = PluckIt.pluckit value, value_handle if value_handle
+        new_key = PluckIt.pluckit(value, key_handle)
+        new_value = PluckIt.pluckit(value, value_handle) if value_handle
       end
 
       # collect results
@@ -48,15 +54,18 @@ module Rekey
 
   private
 
-  def validate_input key_handle, value_handle, &block
+  # a negative arity means -(required + 1): optional args or a splat follow
+  def required_args(block)
+    block.arity < 0 ? -block.arity - 1 : block.arity
+  end
+
+  def validate_input!(key_handle, value_handle, &block)
     if block
-      if (key_handle or value_handle)
-        raise ArgumentError.new 'expected key / value handles, *or* block'
+      unless key_handle.nil? && value_handle.nil?
+        raise ArgumentError, "expected key / value handles, *or* block"
       end
     elsif key_handle.nil?
-      raise ArgumentError.new 'key handle or block required'
+      raise ArgumentError, "key handle or block required"
     end
   end
-
-
 end

data/lib/rekey/version.rb

@@ -0,0 +1,3 @@
+module Rekey
+  VERSION = "4.2.0"
+end

data/lib/rekey.rb

@@ -1,13 +1,7 @@
-require_relative 'rekey/rekey'
-
-
-module Rekey
-  VERSION = '4.0.0'
-end
-
+require_relative "rekey/rekey"
 
 module Enumerable
   def rekey(key_handle = nil, value_handle = nil, &block)
-    Rekey.rekey self, key_handle, value_handle, &block
+    Rekey.rekey(self, key_handle, value_handle, &block)
   end
 end

data/rekey.gemspec

@@ -0,0 +1,26 @@
+require_relative "lib/rekey/version"
+
+Gem::Specification.new do |s|
+  s.authors     = ["Daniel Pepper"]
+  s.description = "Reformat Enumerables into Hashes, using derived keys / values"
+  s.files       = `git ls-files * ':!:spec'`.split("\n")
+  s.homepage    = "https://github.com/dpep/rekey_rb"
+  s.license     = "MIT"
+  s.name        = "rekey"
+  s.summary     = s.description
+  s.version     = Rekey::VERSION
+
+  s.metadata = {
+    "changelog_uri" => "#{s.homepage}/blob/main/CHANGELOG.md",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => s.homepage,
+  }
+
+  s.required_ruby_version = ">= 3.2"
+
+  s.add_dependency "pluckit", ">= 1.3"
+
+  s.add_development_dependency "debug"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "simplecov"
+end

metadata

@@ -1,79 +1,90 @@
 --- !ruby/object:Gem::Specification
 name: rekey
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.2.0
 platform: ruby
 authors:
 - Daniel Pepper
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-09 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pluckit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Reformat Enumerables into Hashes, using derived keys / values
-email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
 - lib/rekey.rb
 - lib/rekey/rekey.rb
-- test/test_array_block.rb
-- test/test_array_handlers.rb
-- test/test_empty_input.rb
-- test/test_hash_block.rb
-- test/test_hash_handlers.rb
-- test/test_invalid_input.rb
-- test/test_monkey_patching.rb
-- test/test_range.rb
-- test/test_regexp.rb
-homepage: https://github.com/dpep/rb_rekey
+- lib/rekey/version.rb
+- rekey.gemspec
+homepage: https://github.com/dpep/rekey_rb
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  changelog_uri: https://github.com/dpep/rekey_rb/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/dpep/rekey_rb
 rdoc_options: []
 require_paths:
 - lib
@@ -81,25 +92,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
-signing_key: 
+rubygems_version: 4.0.16
 specification_version: 4
-summary: Rekey
-test_files:
-- test/test_array_block.rb
-- test/test_array_handlers.rb
-- test/test_empty_input.rb
-- test/test_hash_block.rb
-- test/test_hash_handlers.rb
-- test/test_invalid_input.rb
-- test/test_monkey_patching.rb
-- test/test_range.rb
-- test/test_regexp.rb
+summary: Reformat Enumerables into Hashes, using derived keys / values
+test_files: []

data/test/test_array_block.rb

@@ -1,55 +0,0 @@
-require 'minitest/autorun'
-require_relative '../lib/rekey'
-
-
-class RekeyArrayBlockTest < Minitest::Test
-
-  def setup
-    @input = [*1..3]
-  end
-
-  def test_all
-    assert_equal({
-        1 => 1,
-        2 => 2,
-        3 => 3,
-      },
-      @input.rekey {|v| v }
-    )
-
-    assert_equal({
-        1 => 1,
-        2 => 2,
-        3 => 3,
-      },
-      @input.rekey(&:itself)
-    )
-
-    assert_equal({
-        2 => 1,
-        4 => 2,
-        6 => 3,
-      },
-      @input.rekey {|v| v * 2 }
-    )
-
-    assert_equal({
-        '1' => 1,
-        '2' => 2,
-        '3' => 3,
-      },
-      @input.rekey {|v| v.to_s }
-    )
-
-    assert_equal(
-      { nil => 3 },
-      @input.rekey {|v| nil }
-    )
-
-    assert_equal(
-      { 123 => 3 },
-      @input.rekey { 123 }
-    )
-  end
-
-end

data/test/test_array_handlers.rb

@@ -1,129 +0,0 @@
-require 'minitest/autorun'
-require_relative '../lib/rekey'
-
-
-class RekeyArrayHandlersTest < Minitest::Test
-
-  def setup
-    @input = [*1..3]
-  end
-
-
-  def test_keys
-    assert_equal({
-        '1' => 1,
-        '2' => 2,
-        '3' => 3,
-      },
-      @input.rekey(:to_s)
-    )
-
-    assert_equal({
-        '1' => 1,
-        '2' => 2,
-        '3' => 3,
-      },
-      @input.rekey('to_s')
-    )
-
-    assert_equal({
-        1.0 => 1,
-        2.0 => 2,
-        3.0 => 3,
-      },
-      @input.rekey(:to_f)
-    )
-
-    assert_equal({
-        1.0 => 1,
-        2.0 => 2,
-        3.0 => 3,
-      },
-      @input.rekey(&:to_f)
-    )
-  end
-
-
-  def test_both
-    assert_equal({
-        1 => 1,
-        2 => 2,
-        3 => 3,
-      },
-      @input.rekey(:to_i, :to_i)
-    )
-
-    assert_equal({
-        '1' => 1.0,
-        '2' => 2.0,
-        '3' => 3.0,
-      },
-      @input.rekey(:to_s, :to_f)
-    )
-
-    assert_equal({
-        '1' => 1.0,
-        '2' => 2.0,
-        '3' => 3.0,
-      },
-      @input.rekey('to_s', 'to_f')
-    )
-  end
-
-
-  def test_array_indices
-    array_data = [
-      [ 1, 2, 3 ],
-      [ 4, 5, 6 ],
-      [ 7, 8, 9 ],
-    ]
-
-    assert_equal({
-        1 => 3,
-        4 => 6,
-        7 => 9,
-      },
-      array_data.rekey(0, 2)
-    )
-
-    array_data = [
-      [ 1 ],
-      [ 2, 1 ],
-      [ 3, 2, 1 ],
-    ]
-    assert_equal({
-        1 => 1,
-        2 => 2,
-        3 => 3,
-      },
-      array_data.rekey(0, :count)
-    )
-  end
-
-
-  def test_hash_indices
-    data = [
-      { i: 1, v: 'a' },
-      { i: 2, v: 'b' },
-      { i: 3, v: 'c' },
-    ]
-
-    assert_equal({
-        1 => data[0],
-        2 => data[1],
-        3 => data[2],
-      },
-      data.rekey(:i)
-    )
-
-    assert_equal({
-        1 => 'a',
-        2 => 'b',
-        3 => 'c',
-      },
-      data.rekey(:i, :v)
-    )
-  end
-
-
-end

data/test/test_empty_input.rb

@@ -1,25 +0,0 @@
-require 'minitest/autorun'
-require 'set'
-require_relative '../lib/rekey'
-
-
-class RekeyEmptyInputTest < Minitest::Test
-
-  def test_all
-    assert_equal(
-      {},
-      [].rekey(:k, :v)
-    )
-
-    assert_equal(
-      {},
-      {}.rekey(:k, :v)
-    )
-
-    assert_equal(
-      {},
-      Set.new.rekey(:k, :v)
-    )
-  end
-
-end

data/test/test_hash_block.rb

@@ -1,74 +0,0 @@
-require 'minitest/autorun'
-require_relative '../lib/rekey'
-
-
-class RekeyHashBlockTest < Minitest::Test
-  def setup
-    @input = {
-      a: 1,
-      b: 2,
-      c: 3,
-    }
-  end
-
-  def test_arity1_keys
-    assert_equal({
-        1 => 1,
-        2 => 2,
-        3 => 3,
-      },
-      @input.rekey {|v| v }
-    )
-
-    assert_equal({
-        '1' => 1,
-        '2' => 2,
-        '3' => 3,
-      },
-      @input.rekey {|v| v.to_s }
-    )
-
-    # it can use Arrays as Hash keys...if you really want to
-    assert_equal({
-        [1] => 1,
-        [2] => 2,
-        [3] => 3,
-      },
-      @input.rekey {|v| [v] }
-    )
-  end
-
-  def test_arity2_keys
-    assert_equal({
-        1 => 1,
-        2 => 2,
-        3 => 3,
-      },
-      @input.rekey {|k, v| v }
-    )
-
-    assert_equal({
-        a: 1,
-        b: 2,
-        c: 3,
-      },
-      @input.rekey {|k, v| k }
-    )
-
-    assert_equal({
-        'aa' => 1,
-        'bb' => 2,
-        'cc' => 3,
-      },
-      @input.rekey {|k, v| k.to_s * 2 }
-    )
-  end
-
-  def test_nil_key
-    assert_equal(
-      { nil => 3 },
-      @input.rekey {|k, v| nil }
-    )
-  end
-
-end

data/test/test_hash_handlers.rb

@@ -1,112 +0,0 @@
-require 'minitest/autorun'
-require_relative '../lib/rekey'
-
-
-class RekeyHashHandlersTest < Minitest::Test
-
-  def setup
-    @input = {
-      a: 1,
-      b: 2,
-      c: 3,
-    }
-  end
-
-
-  def test_keys
-    assert_equal({
-        '1' => 1,
-        '2' => 2,
-        '3' => 3,
-      },
-      @input.rekey(:to_s)
-    )
-
-    assert_equal({
-        1.0 => 1,
-        2.0 => 2,
-        3.0 => 3,
-      },
-      @input.rekey(:to_f)
-    )
-  end
-
-
-  def test_both
-    assert_equal({
-        1 => 1,
-        2 => 2,
-        3 => 3,
-      },
-      @input.rekey(:to_i, :to_i)
-    )
-
-    assert_equal({
-        '1' => 1.0,
-        '2' => 2.0,
-        '3' => 3.0,
-      },
-      @input.rekey(:to_s, :to_i)
-    )
-
-    assert_equal({
-        '1' => 1.0,
-        '2' => 2.0,
-        '3' => 3.0,
-      },
-      @input.rekey('to_s', 'to_i')
-    )
-  end
-
-
-  def test_hash_array
-    data = {
-      a: [ 1, 2, 3 ],
-      b: [ 4, 5, 6 ],
-      c: [ 7, 8, 9 ],
-    }
-
-    assert_equal({
-        1 => 2,
-        4 => 5,
-        7 => 8,
-      },
-      data.rekey(0, 1)
-    )
-
-    assert_equal({
-        1 => 3,
-        4 => 6,
-        7 => 9,
-      },
-      data.rekey(:min, :max)
-    )
-  end
-
-
-  def test_hash_hash
-    data = {
-      a: { i: 1, v: 2 },
-      b: { i: 2, v: 4 },
-      c: { i: 3, v: 6 },
-    }
-
-    assert_equal({
-        1 => { i: 1, v: 2 },
-        2 => { i: 2, v: 4 },
-        3 => { i: 3, v: 6 },
-      },
-      data.rekey(:i)
-    )
-
-    assert_equal({
-        1 => 2,
-        2 => 4,
-        3 => 6,
-      },
-      data.rekey(:i, :v)
-    )
-
-  end
-
-end

data/test/test_invalid_input.rb

@@ -1,50 +0,0 @@
-require 'minitest/autorun'
-require_relative '../lib/rekey'
-
-
-class RekeyInvalidInputTest < Minitest::Test
-  def setup
-    @input = [*1..3]
-  end
-
-
-  def test_nil
-    assert_raises ArgumentError do
-      @input.rekey
-    end
-
-    assert_raises ArgumentError do
-      @input.rekey nil
-    end
-
-    assert_raises ArgumentError do
-      @input.rekey nil, :v
-    end
-
-    # unfortunately, these still pass
-    @input.rekey(nil) {|v| v}
-    @input.rekey(nil, nil) {|v| v}
-  end
-
-
-  def test_handles_and_block
-    assert_raises ArgumentError do
-      @input.rekey(:k) {|k| 1}
-    end
-
-    assert_raises ArgumentError do
-      @input.rekey(:k, :v) {|k| 1}
-    end
-  end
-
-
-  def test_block_underflow
-    # block requesting key and value, but @input
-    # doesn't have keys
-    assert_raises ArgumentError do
-      @input.rekey {|k, v| 1}
-    end
-  end
-
-
-end

data/test/test_monkey_patching.rb

@@ -1,44 +0,0 @@
-require 'minitest/autorun'
-require 'set'
-require_relative '../lib/rekey/rekey'
-
-
-class MonkeyPatchingTest < Minitest::Test
-
-  def test_not_installed
-    if defined? Rekey::VERSION
-      # entire library was loaded, so these tests are invalid.
-      # this happens when run through `rake`
-      skip
-    end
-
-    # `require 'rekey/rekey'` should load Rekey
-    assert Rekey
-
-    # but no monkey patching
-    assert_raises NoMethodError do
-      [ 1, 2, 3 ].rekey 0
-    end
-
-    assert_raises NoMethodError do
-      { a: 1 }.rekey 0
-    end
-
-    assert_raises NoMethodError do
-      Set.new([ 1, 2, 3 ]).rekey 0
-    end
-
-    puts 'yay, no monkey patching'
-  end
-
-
-  def test_pluckit
-    assert PluckIt
-
-    assert_raises NoMethodError do
-      [ 1, 2, 3 ].pluck 0
-    end
-  end
-
-
-end

data/test/test_range.rb

@@ -1,30 +0,0 @@
-require 'minitest/autorun'
-require_relative '../lib/rekey'
-
-
-class RekeyRangeTest < Minitest::Test
-
-  def setup
-    @input = [
-      [ 1, 2, 3 ],
-      [ 4, 5, 6 ],
-    ]
-  end
-
-  def test_stuff
-    assert_equal({
-        [ 1, 2 ] => [ 1, 2, 3 ],
-        [ 4, 5 ] => [ 4, 5, 6 ],
-      },
-      @input.rekey(0..1)
-    )
-
-    assert_equal({
-        3 => [ 1, 2 ],
-        6 => [ 4, 5 ],
-      },
-      @input.rekey(2, 0..1)
-    )
-  end
-
-end

data/test/test_regexp.rb

@@ -1,30 +0,0 @@
-require 'minitest/autorun'
-require_relative '../lib/rekey'
-
-
-class RekeyRegexpTest < Minitest::Test
-
-  def setup
-    @input = [
-      [ 'a', 'aa', 'b', 'ba', 'dd' ],
-      [ 'b', 'c', 'bc', 'de' ],
-    ]
-  end
-
-  def test_stuff
-    assert_equal({
-        'a' => ['a', 'aa', 'ba'],
-        'b' => [],
-      },
-      @input.rekey(0, /a/)
-    )
-
-    assert_equal({
-        ['dd'] => ['b', 'ba'],
-        ['de'] => ['b', 'bc'],
-      },
-      @input.rekey(/d/, /b/)
-    )
-  end
-
-end