hmap 0.1.0 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b91ede0c8bd571c77da15568b4418141005fd68b
+  data.tar.gz: 5d3be03169ec696f3a4c5787a54eed3a7a82e4f1
+SHA512:
+  metadata.gz: 4490aad3efaa67f76f58fd9af4a61e5cf26c919140ecef9b11ac637b37d4b763b191efc84c218d7e6e3e7e0441deaff432201014756754e64384d16e6daadf7c
+  data.tar.gz: 2b443f56320051e2f824eb147de39ed6ecb8b9559041cee6692ed6986ad57b13078503c40b3206e409f4a682c3779977d4d13f110b24d3073380967f05a474fb

data/lib/hmap.rb

@@ -1,19 +1,6 @@
-# Copyright © 2011, José Pablo Fernández
+require_relative 'hmap/hmap'
 
-class Hash
-  def hmap(*attrs, &block)
-    map(*attrs, &block).inject({}) do |new_hash, pair|
-      if pair.is_a? Hash
-        new_hash.merge(pair)
-      elsif pair.is_a? Array
-        if pair.length != 2
-          raise "When using hmap, when you return arrays, they must have two and only two elements; #{pair} doesn't"
-        end
-        new_hash[pair[0]] = pair[1]
-        new_hash
-      else
-        raise "When using hmap you need to return arrays or hashes, #{pair} isn't either."
-      end
-    end
-  end
+
+module Hmap
+  VERSION = '1.0.0'
 end

data/lib/hmap/hmap.rb

@@ -0,0 +1,65 @@
+class Hash
+
+  class << self
+
+    # create Hash from given keys and mapped values
+    def map(obj, &block)
+      res = obj.map do |*args|
+        block.call(*args)
+      end
+
+      Hash[obj.zip res]
+    end
+
+
+    # map an Enumerable into a Hash, like Hash[obj.map ... ]
+    def hmap(obj, &block)
+      Hash[
+        obj.map do |*args|
+          block.call(*args)
+        end.compact
+      ]
+    end
+
+  end  # class << self
+
+
+  # map the block's results back to a hash
+  def hmap(&block)
+    clone.hmap!(&block)
+  end
+
+  def hmap!(&block)
+    data = Hash.hmap(self, &block)
+    clear
+    merge! data
+  end
+
+
+  # map keys, but preserve associated values
+  # ie. http://apidock.com/rails/v4.2.7/Hash/transform_keys
+  def kmap(&block)
+    clone.kmap!(&block)
+  end
+
+  def kmap!(&block)
+    hmap! do |k, v|
+      [ block.arity <= 1 ? block.call(k) : block.call(k, v), v ]
+    end
+  end
+
+
+  # map values, but preserve associated keys
+  # ie. http://apidock.com/rails/v4.2.7/Hash/transform_values
+  def vmap(&block)
+    clone.vmap!(&block)
+  end
+
+  def vmap!(&block)
+    each do |k, v|
+      self[k] = block.arity <= 1 ? block.call(v) : block.call(k, v)
+    end
+  end
+
+
+end

data/test/test_hmap.rb

@@ -0,0 +1,279 @@
+require 'minitest/autorun'
+require 'hmap'
+
+
+class HmapTest < Minitest::Test
+
+  def test_Hash_map
+    data = {
+      c: 2,
+      b: 3,
+      a: 1,
+    }
+
+    assert_equal(
+      data,
+      Hash.map(data.keys) {|x| data[x]}
+    )
+
+    assert_equal(
+      {},
+      Hash.map([]) {|x| nil}
+    )
+
+    assert_equal(
+      {
+        1 => nil,
+        2 => nil,
+        3 => nil,
+      },
+      Hash.map([1,2,3]) {|x| nil}
+    )
+
+    assert_equal(
+      {
+        1 => false,
+        2 => false,
+        3 => true,
+      },
+      Hash.map([1,2,3]) {|x| x > 2 }
+    )
+
+    assert_equal(
+      { 1 => [ 2, 3 ] },
+      Hash.map([1]) {|x| [ 2, 3 ] }
+    )
+  end
+
+
+  def test_Hash_hmap
+    data = {
+      c: 2,
+      b: 3,
+      a: 1,
+    }
+
+    assert_equal(
+      data,
+      Hash.hmap(data) {|k, v| [k, v]}
+    )
+
+    assert_equal(
+      { a: 2, b: 6, c: 4 },
+      Hash.hmap(data) {|k, v| [k, v * 2]}
+    )
+
+    assert_equal(
+      { 1 => 2, 2 => 4 },
+      Hash.hmap([1, 2]) {|x| [ x, x * 2 ] }
+    )
+
+    assert_equal(
+      data,
+      Hash.hmap(data.keys) {|x| [x, data[x]]}
+    )
+
+    assert_equal(
+      { nil => 3 },
+      Hash.hmap([1,2,3]) {|x| [nil, x]}
+    )
+
+    assert_equal(
+      {},
+      Hash.hmap([]) {|x| nil}
+    )
+
+    assert_equal(
+      {},
+      Hash.hmap([1, 2, 3]) {|x| nil}
+    )
+  end
+
+
+  def test_hmap
+    data = {
+      c: 2,
+      b: 3,
+      a: 1,
+    }
+
+    assert_equal(
+      {
+        c: 4,
+        b: 6,
+        a: 2,
+      },
+      data.hmap {|k, v| [k, v * 2]}
+    )
+
+    assert_equal(
+      {
+        cc: 4,
+        bb: 6,
+        aa: 2,
+      },
+      data.hmap {|k, v| [(k.to_s * 2).to_sym, v * 2]}
+    )
+
+    assert_equal(
+      {},
+      {}.hmap {|k, v| [k, v * 2]}
+    )
+
+    assert_equal(
+      {},
+      {a: 1}.hmap {|k, v| nil}
+    )
+
+
+    assert_equal(
+      {
+        c: 4,
+        b: 6,
+        a: 2,
+      },
+      data.hmap! {|k, v| [k, v * 2]}
+    )
+    assert_equal(
+      {
+        c: 4,
+        b: 6,
+        a: 2,
+      },
+      data
+    )
+  end
+
+
+  def test_kmap
+    data = {
+      'a' => 1,
+      'b' => 2,
+      'c' => 3,
+    }
+
+    assert_equal(
+      data,
+      data.kmap(&:to_s)
+    )
+
+    assert_equal(
+      {
+        'aa' => 1,
+        'bb' => 2,
+        'cc' => 3,
+      },
+      data.kmap {|k| k * 2}
+    )
+
+    assert_equal(
+      {
+        'aa' => 1,
+        'bb' => 2,
+        'cc' => 3,
+      },
+      data.kmap {|k, v| k * 2}
+    )
+
+    assert_equal(
+      {
+        'aa' => 1,
+        'bb' => 2,
+        'cc' => 3,
+      },
+      data.kmap! {|k, v| k * 2}
+    )
+    assert_equal(
+      {
+        'aa' => 1,
+        'bb' => 2,
+        'cc' => 3,
+      },
+      data
+    )
+  end
+
+
+  def test_vmap
+    data = {
+      a: 1,
+      b: 2,
+      c: 3,
+    }
+
+    assert_equal(
+      {
+        a: 1.0,
+        b: 2.0,
+        c: 3.0,
+      },
+      data.vmap(&:to_f)
+    )
+
+    assert_equal(
+      {
+        a: 2,
+        b: 4,
+        c: 6,
+      },
+      data.vmap {|v| v * 2}
+    )
+
+    assert_equal(
+      {
+        a: 2,
+        b: 4,
+        c: 6,
+      },
+      data.vmap {|k, v| v * 2}
+    )
+
+    assert_equal(
+      {
+        a: :a,
+        b: :b,
+        c: :c,
+      },
+      data.vmap {|k, v| k}
+    )
+
+
+    assert_equal(
+      {
+        a: 2,
+        b: 4,
+        c: 6,
+      },
+      data.vmap! {|v| v * 2}
+    )
+    assert_equal(
+      {
+        a: 2,
+        b: 4,
+        c: 6,
+      },
+      data
+    )
+  end
+
+
+  def test_default_value
+    data = Hash.new 123
+
+    assert_equal(
+      123,
+      data.kmap {|v| nil }[:abc]
+    )
+
+    assert_equal(
+      123,
+      data.vmap {|v| nil }[:abc]
+    )
+
+    assert_equal(
+      123,
+      data.hmap {|v| nil }[:abc]
+    )
+  end
+
+end

metadata

@@ -1,73 +1,89 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: hmap
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: 
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 1.0.0
 platform: ruby
-authors: 
-- "J. Pablo Fern\xC3\xA1ndez"
+authors:
+- Daniel Pepper
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-02-19 00:00:00 +01:00
-default_executable: 
-dependencies: []
-
-description: A map for hashes that returs a hash
+date: 2018-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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'
+- !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: Improved Hash mapping functions
 email: 
-- pupeno@pupeno.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- Gemfile
-- Rakefile
-- hmap.gemspec
+files:
 - lib/hmap.rb
-- lib/hmap/version.rb
-- test/hmap_test.rb
-has_rdoc: true
-homepage: ""
-licenses: []
-
+- lib/hmap/hmap.rb
+- test/test_hmap.rb
+homepage: https://github.com/dpep/rb_hmap
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: hmap
-rubygems_version: 1.5.2
+rubyforge_project: 
+rubygems_version: 2.6.11
 signing_key: 
-specification_version: 3
-summary: A map for hashes that returns a hash
-test_files: 
-- test/hmap_test.rb
+specification_version: 4
+summary: Hmap
+test_files:
+- test/test_hmap.rb

data/Gemfile

@@ -1,6 +0,0 @@
-# Copyright © 2011, José Pablo Fernández
-
-source "http://rubygems.org"
-
-# Specify your gem's dependencies in hmap.gemspec
-gemspec

data/Rakefile

@@ -1,10 +0,0 @@
-# Copyright © 2011, José Pablo Fernández
-
-require "bundler"
-Bundler::GemHelper.install_tasks
-
-require "rake/testtask"
-Rake::TestTask.new do |t|
-  t.test_files = FileList["test/*.rb"]
-  t.verbose = true
-end

data/hmap.gemspec

@@ -1,23 +0,0 @@
-# -*- encoding: utf-8 -*-
-# Copyright © 2011, José Pablo Fernández
-
-$:.push File.expand_path("../lib", __FILE__)
-require "hmap/version"
-
-Gem::Specification.new do |s|
-  s.name        = "hmap"
-  s.version     = Hmap::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["J. Pablo Fernández"]
-  s.email       = ["pupeno@pupeno.com"]
-  s.homepage    = ""
-  s.summary     = %q{A map for hashes that returns a hash}
-  s.description = %q{A map for hashes that returs a hash}
-
-  s.rubyforge_project = "hmap"
-
-  s.files         = `git ls-files`.split("\n").grep(/^[^\.]/)
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-end

data/lib/hmap/version.rb

@@ -1,5 +0,0 @@
-# Copyright © 2011, José Pablo Fernández
-
-module Hmap
-  VERSION = "0.1.0"
-end

data/test/hmap_test.rb

@@ -1,35 +0,0 @@
-# Copyright © 2011, José Pablo Fernández
-
-require "hmap.rb"
-require "test/unit"
-
-class HashTest < Test::Unit::TestCase
-  def test_empty
-    assert_equal({}, {}.hmap { |a, b| [a, b] })
-  end
-
-  def test_raises_when_totally_invalid
-    assert_raises RuntimeError do
-      {:a => :b}.hmap { |a, _| a }
-    end
-  end
-
-  def test_raises_when_invalid_array
-    assert_raises RuntimeError do
-      {:a => :b}.hmap { |a, _| [a] }
-    end
-    assert_raises RuntimeError do
-      {:a => :b}.hmap { |a, b| [a, b, b] }
-    end
-  end
-
-  def test_identity_with_hash
-    hash = {:a => :b, :c => :d, :e => :f}
-    assert_equal(hash, hash.hmap { |a, b| {a => b} })
-  end
-
-  def test_identity_with_array
-    hash = {:a => :b, :c => :d, :e => :f}
-    assert_equal(hash, hash.hmap { |a, b| [a, b] })
-  end
-end