rekey 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aef7b449f66795bace280c82a74dc2ec9b6fb0e9
-  data.tar.gz: 00ce3968fcfa316c3f9f49279e26b46c0bd30d8c
+  metadata.gz: fa0f9ac28de18ed312d7886726801ae4eeabc6ed
+  data.tar.gz: dfa6edfbb2dfd2313044f416e56bdeae376c3997
 SHA512:
-  metadata.gz: 23b83545770104e3f968e1dfcf7ae3a503a87cce2b9452773bd4edec3b0da3ea3d380de358aea09aaa625e3fbfafbf53a858cb2bc1851f10d176886641af4c51
-  data.tar.gz: b78c2be0c10cfc6f56594b08987208433a7b2b2f1b255296bc996f7cc1bfea7614934095a08455a14b4dcb6d6c86479e4b7a9c035455b3579a483870129c9f03
+  metadata.gz: fe5cb87711746ab6717dd2e90566110841a8520dd611c88fa56b7f93734dfd36e8416f67b94fc4539a30cff793e6e583b4ece0f5529c466cd3f4327ab2be4fb1
+  data.tar.gz: 1c1f02d4cef3e52f5d40fdad3ea2dac4299100af0971e0a361e73662e536ae7a79efc94b7d26ac9d1b75d5a42022f956263bd751b715e3a365f3acfb5e3cfe10

data/lib/rekey.rb

@@ -1,6 +1,3 @@
-require 'awesome_print'
-require 'byebug'
-
 module Rekey
   class << self
 
@@ -12,7 +9,7 @@ module Rekey
         end
       else
         unless key_handle or value_handle
-          raise ArgumentError.new 'expected key_handle or value_handle'
+          raise ArgumentError.new 'expected 1 or 2 args, got 0'
         end
       end
 
@@ -28,14 +25,8 @@ module Rekey
         proc {|v| v}
       end
 
+      # return type will be determined later
       res = nil
-      # determine return type.  generally a Hash, except when input
-      # is an Array and key_handle is null
-      if block
-        res = {}
-      else
-        res = (key_handle or enumerable.respond_to?(:keys)) ? {} : []
-      end
 
       enumerable.each do |*args|
         key = key_fn.call *args
@@ -45,13 +36,19 @@ module Rekey
 
         if block
           if block.arity <= 0
-            # function pointer
+            # function pointer, eg. &:to_i
             new_key = block.call value
           elsif block.arity == 1
             # standard block
             new_key = block.call value
           else
-            new_key, new_value = block.call key, value
+            data = block.call key, value
+            if data.is_a? Array
+              new_key, new_value = data
+            else
+              # only returned a new key value
+              new_key = data
+            end
           end
         else
           new_key = pull value, key_handle if key_handle
@@ -59,7 +56,21 @@ module Rekey
         end
 
         # collect results
+
+        unless res
+          # determine return type based on the first
+          # computed key value
+          res = new_key ? {} : []
+        end
+
         if res.is_a? Array
+          unless new_key.nil?
+            # safeguard against stupidity
+            raise ArgumentError.new(
+              "not expecting a key value, got: #{new_key}"
+            )
+          end
+
           res.push new_value
         else
           res[new_key] = new_value
@@ -73,15 +84,28 @@ module Rekey
     private
 
     def pull v, handle
-          # byebug
-      if v.respond_to? handle
+      if ([Symbol, String].include? handle.class) and v.respond_to? handle
         if v.method(handle).arity <= 0
           v.send handle
         else
           v.send handle, v
         end
-      else
+      elsif v.is_a? Array
+        if handle.is_a? String and handle.include? '..'
+          # properly format ranges
+          ends = handle.split('.').reject(&:empty?).map(&:to_i)
+          handle = Range.new(
+            ends.first,
+            ends.last,
+            handle.include?('...')   # exclude_end
+          )
+        end
 
+        v[handle]
+      elsif v.is_a? Hash
+        v[handle]
+      else
+        raise ArgumentError.new "invalid handle: #{handle}, for value #{v}"
       end
     end
 

data/lib/rekey/version.rb

@@ -1,3 +1,3 @@
 module Rekey
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end

data/test/test_array_block.rb

@@ -0,0 +1,76 @@
+require 'minitest/autorun'
+require 'rekey'
+
+
+class RekeyArrayBlockTest < Minitest::Test
+
+  def setup
+    @input = [*1..3]
+  end
+
+  def test_both
+    assert_equal({
+        1 => 1,
+        2 => 2,
+        3 => 3,
+      },
+      @input.rekey {|k, v| [v, v] }
+    )
+
+    assert_equal({
+        '1' => 1.0,
+        '2' => 2.0,
+        '3' => 3.0,
+      },
+      @input.rekey {|k, v| [v.to_s, v.to_f] }
+    )
+  end
+
+  def test_keys
+    assert_equal({
+        1 => 1,
+        2 => 2,
+        3 => 3,
+      },
+      @input.rekey {|v| v }
+    )
+
+    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 }
+    )
+  end
+
+  def test_nil_key
+    assert_equal(
+      @input,
+      @input.rekey {|k, v| [nil, v.to_i] }
+    )
+
+    assert_equal(
+      @input,
+      # k is nil because input is array
+      @input.rekey {|k, v| [k, v.to_i] }
+    )
+
+    assert_equal([
+        '1',
+        '2',
+        '3',
+      ],
+      @input.rekey {|k, v| [nil, v.to_s] }
+    )
+  end
+
+end

data/test/test_array_handlers.rb

@@ -0,0 +1,183 @@
+require 'minitest/autorun'
+require 'rekey'
+
+
+class RekeyArrayHandlersTest < Minitest::Test
+
+  def setup
+    @input = [*1..3]
+  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_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_values
+    assert_equal(
+      @input,
+      @input.rekey(nil, :to_i)
+    )
+
+    assert_equal(
+      @input.map(&:to_f),
+      @input.rekey(nil, :to_f)
+    )
+
+    assert_equal(
+      @input.map(&:to_s),
+      @input.rekey(nil, 'to_s')
+    )
+  end
+
+  def test_array_indices
+    array_data = [
+      [ 1, 2, 3 ],
+      [ 4, 5, 6 ],
+      [ 7, 8, 9 ],
+    ]
+
+    assert_equal(
+      array_data,
+      array_data.rekey(nil, :to_a)
+    )
+
+    assert_equal(
+      [ 1, 4, 7 ],
+      array_data.rekey(nil, 0)
+    )
+
+    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_array_hash
+    data = [
+      { a: 1 },
+      { b: 2 },
+      { c: 3 },
+    ]
+
+    assert_equal(
+      [ [:a], [:b], [:c] ],
+      data.rekey(nil, :keys)
+    )
+
+    assert_equal(
+      [ :a, :b, :c ],
+      data.rekey(nil, :keys).rekey(nil, :first)
+    )
+
+    assert_equal({
+        { a: 1 }.hash => data.first,
+      },
+      data.take(1).rekey(:hash)
+    )
+
+    assert_equal({
+        { a: 1 }.hash => [:a, 1],
+      },
+      data.take(1).rekey(:hash, :first)
+    )
+  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_hash_block.rb

@@ -0,0 +1,100 @@
+require 'minitest/autorun'
+require 'rekey'
+
+
+class RekeyHashBlockTest < Minitest::Test
+  def setup
+    @input = {
+      a: 1,
+      b: 2,
+      c: 3,
+    }
+  end
+
+  def test_both
+    assert_equal(
+      @input,
+      @input.rekey {|k, v| [k, v] }
+    )
+
+    assert_equal({
+        1 => 1,
+        2 => 2,
+        3 => 3,
+      },
+      @input.rekey {|k, v| [v, v] }
+    )
+
+    assert_equal({
+        '1' => 1.0,
+        '2' => 2.0,
+        '3' => 3.0,
+      },
+      @input.rekey {|k, v| [v.to_s, v.to_f] }
+    )
+  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([
+        1,
+        2,
+        3,
+      ],
+      @input.rekey {|k, v| [nil, v] }
+    )
+  end
+
+end

data/test/test_hash_handlers.rb

@@ -0,0 +1,131 @@
+require 'minitest/autorun'
+require 'rekey'
+
+
+class RekeyHashHandlersTest < Minitest::Test
+  def setup
+    @input = {
+      a: 1,
+      b: 2,
+      c: 3,
+    }
+  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_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_values
+    assert_equal(
+      @input,
+      @input.rekey(nil, :to_i)
+    )
+
+    assert_equal({
+        a: '1',
+        b: '2',
+        c: '3',
+      },
+      @input.rekey(nil, :to_s)
+    )
+
+    assert_equal({
+        a: '1',
+        b: '2',
+        c: '3',
+      },
+      @input.rekey(nil, 'to_s')
+    )
+  end
+
+  def test_hash_array
+    data = {
+      a: [ 1, 2, 3 ],
+      b: [ 4, 5, 6 ],
+      c: [ 7, 8, 9 ],
+    }
+
+    assert_equal({
+        a: 1,
+        b: 4,
+        c: 7,
+      },
+      data.rekey(nil, 0)
+    )
+
+    assert_equal({
+        1 => 2,
+        4 => 5,
+        7 => 8,
+      },
+      data.rekey(0, 1)
+    )
+  end
+
+  def test_hash_hash
+    data = {
+      a: { i: 1, v: 2 },
+      b: { i: 2, v: 4 },
+      c: { i: 3, v: 6 },
+    }
+
+    assert_equal({
+        a: 1,
+        b: 2,
+        c: 3,
+      },
+      data.rekey(nil, :i)
+    )
+
+    assert_equal({
+        1 => 2,
+        2 => 4,
+        3 => 6,
+      },
+      data.rekey(:i, :v)
+    )
+
+  end
+
+end

data/test/test_ranges.rb

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

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rekey
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-28 00:00:00.000000000 Z
-dependencies: []
+date: 2016-12-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: |2
       For turning Arrays into Hashes, with keys computed from the Array
       contents.  Or for rekeying Hashes.
@@ -23,6 +37,11 @@ extra_rdoc_files: []
 files:
 - lib/rekey.rb
 - lib/rekey/version.rb
+- test/test_array_block.rb
+- test/test_array_handlers.rb
+- test/test_hash_block.rb
+- test/test_hash_handlers.rb
+- test/test_ranges.rb
 homepage: https://github.com/d1hotpep/rekey
 licenses:
 - MIT
@@ -47,4 +66,9 @@ rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Rekey
-test_files: []
+test_files:
+- test/test_array_block.rb
+- test/test_array_handlers.rb
+- test/test_hash_block.rb
+- test/test_hash_handlers.rb
+- test/test_ranges.rb