hash_dial 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9534eaddcb86bd7312266b1e8f9e4f3b820907156ad51b8dc217e7a6bd0aa4bb
-  data.tar.gz: b1655d5175679674f0c0771da15a23cca7ad57531557dff5992d109d8549f238
+  metadata.gz: cf7a8293144381456540a20c18cd5255e697f52d92d0dcbbde771ab7613d7d60
+  data.tar.gz: a34d06f35126cddb77126fbf0f30463440082c95337447595d24c07101dcce5e
 SHA512:
-  metadata.gz: 85de5edb9b862b2b7f316cd503153008d35d112df936a95edd8c11bc67f462084d421b9c32e73968cb6db706ae49f69937465885e7d7f67ed0ae6959fef695d6
-  data.tar.gz: 8668b5f99eea13ae09b8a5a702698a662cc92eb56934bf8e4c586485683c775f5ad4cfe9c852314c6a2d9c34343dcb402d10f054f268e7d3d4261460453179b0
+  metadata.gz: d2152d053c75459522cb877896add0d324406e6b99a8092985d6e92f117958732cc2ca5906e90664827b38685ad67c50d630676cd95b1ad025ab496b5da7151e
+  data.tar.gz: 23c1c0c5c6ed8941d39656cf06352cdcb76ffcc03733a691637008e12e869ef95438bb7abb23f5761ac677d4f7572998fbf1ffb83fac73a1af1f2f42f3bbf967

data/Gemfile.lock

@@ -1,35 +1,35 @@
-PATH
-  remote: .
-  specs:
-    hash_dial (1.0.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    diff-lcs (1.3)
-    rake (10.5.0)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.0)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.17)
-  hash_dial!
-  rake (~> 10.0)
-  rspec (~> 3.0)
-
-BUNDLED WITH
-   1.17.2
+PATH
+  remote: .
+  specs:
+    hash_dial (1.0.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  hash_dial!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.17.2

data/README.md

@@ -1,64 +1,3 @@
 # HashDial (Ruby Gem)
 
-**Avoid all errors when accessing a deeply nested Hash key.** HashDial goes one step beyond `Hash::dig()` by returning `nil` (or your default) if the keys requested are invalid for any reason.
-
-In particular, if you try to access a key on a value that isn't a hash, `dig()` will cause an error where HashDial will not.
-
-```ruby
-hash = {a: {b: {c: true}, d: 5}}
-hash.dig( :a, :d, :c) #=> TypeError: Integer does not have #dig method
-hash.call(:a, :d, :c) #=> nil
-hash.call(:a, :b, :c) #=> true
-```
-
-**Bonus: you don't even need to fiddle with existing code.** If you have already written something to access a deep hash key, just surround this with `dial` and `call` (rather than changing it to the form above as function parameters).
-
-```ruby
- hash[:a][:d][:c]           #=> TypeError: no implicit conversion of Symbol into Integer
-
-#hash →   [:a][:d][:c]
-#     ↓                ↓
- hash.dial[:a][:d][:c].call #=> nil
-```
-
-## Explanation
-
-We use the concept of placing a phone-call: you can 'dial' any set of keys regardless of whether they exist (like entering a phone number), then finally place the 'call'. If the key is invalid for any reason you get nil/default (like a wrong number); otherwise you get the value (you're connected).
-
-This works by intermediating your request with a HashDialler object. Trying to access keys on this object simply builds up a list of keys to use when you later place the 'call'.
-
-## Usage
-
-```ruby
-require 'hash_dial'
-```
-
-### Use it like dig()
-
-If you want to follow this pattern, it works in the same way. You can't change the default return value when using this pattern.
-
-```ruby
-hash.call(:a, :b, :c) # Returns the value at hash[:a][:b][:c] or nil
-```
-
-### Use it like a Hash -- allows default return value
-
-```ruby
-hash.dial[:a][:b][:c].call          # Returns the value at hash[:a][:b][:c] or nil
-hash.dial[:a][:b][:c].call('Ooops') # Returns the value at hash[:a][:b][:c] or 'Ooops'
-```
-
-If you don't do this all in one line, you can access the HashDialler object should you want to manipulate it:
-
-```ruby
-dialler = hash.dial # Returns a HashDialler object referencing hash
-dialler[:a] # Adds :a to the list of keys to dial (returns self)
-dialler.dial!(:b, :c) # Longhand way of adding more keys (returns self)
-dialler.undial! # Removes the last-added key (returns self)
-dialler[:c][:d] # Adds two more keys (returns self)
-dialler += :e # Adds yet one more (returns self)
-dialler -= :a # Removes all such keys from the list (returns self)
-# So far we have dialled [:b][:c][:d][:e]
-dialler.call # Returns the value at hash[:b][:c][:d][:e] or nil
-dialler.hangup # Returns the original hash by reference
-```
+This gem is deprecated. It is replaced entirely by [KeyDial](https://github.com/ConvincibleMedia/ruby-gem-key_dial) which does the same thing, but works on Hashes, Arrays and Structs as well.

data/hash_dial.gemspec

@@ -1,29 +1,31 @@
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "hash_dial/version"
-
-Gem::Specification.new do |spec|
-    spec.name          = "hash_dial"
-    spec.version       = HashDial::VERSION
-    spec.authors       = ["Convincible"]
-    spec.email         = ["development@convincible.media"]
-
-    spec.summary       = "Access (deeply nested) hash keys. Get the value, or nil on any error. (Even safer than Hash::dig)."
-    spec.description   = "Avoid all errors when accessing (deeply nested) Hash keys. Safer than dig(), as will quietly return nil (or your default) if the keys requested are invalid for any reason at all. Bonus: you don't even need to fiddle with existing code. If you have already written something to access a deep hash key (e.g. hash[:a][:b][:c]), just surround this with '.dial' and '.call'."
-    spec.homepage      = "https://github.com/ConvincibleMedia/ruby-gem-hash_dial"
-
-    # Specify which files should be added to the gem when it is released.
-    # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-    spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-        `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-    end
-    spec.bindir        = "exe"
-    spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-    spec.require_paths = ["lib"]
-    spec.required_ruby_version = '~> 2.3'
-
-    spec.add_development_dependency "bundler", "~> 1.17"
-    spec.add_development_dependency "rake", "~> 10.0"
-    spec.add_development_dependency "rspec", "~> 3.0"
-end
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "hash_dial/version"
+
+Gem::Specification.new do |spec|
+    spec.name          = "hash_dial"
+    spec.version       = HashDial::VERSION
+    spec.authors       = ["Convincible"]
+    spec.email         = ["development@convincible.media"]
+
+    spec.summary       = "Access (deeply nested) hash keys. Get the value, or nil on any error. (Even safer than Hash::dig). Deprecated - use KeyDial."
+    spec.description   = "Avoid all errors when accessing (deeply nested) Hash keys. Safer than dig(), as will quietly return nil (or your default) if the keys requested are invalid for any reason at all. This gem is deprecated - use KeyDial instead, which does the same thing but works on Hashes, Arrays and Structs as well."
+    spec.homepage      = "https://github.com/ConvincibleMedia/ruby-gem-hash_dial"
+
+    # Specify which files should be added to the gem when it is released.
+    # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+    spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+        `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    end
+    spec.bindir        = "exe"
+    spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+    spec.require_paths = ["lib"]
+    spec.required_ruby_version = '>= 2.3'
+
+    spec.add_development_dependency "bundler", "~> 1.17"
+    spec.add_development_dependency "rake", "~> 10.0"
+    spec.add_development_dependency "rspec", "~> 3.0"
+
+    spec.post_install_message = "The 'hash_dial' gem has been deprecated and replaced by 'key_dial'."
+end

data/lib/hash_dial.rb

@@ -1,29 +1,31 @@
-require "hash_dial/version"
-require "hash_dial/hash_dialler"
-
-module HashDial
-
-    # Called on a Hash, returns a HashDialler object for that Hash.
-    #
-    # @param lookup Parameters to this method form initial hash keys to dial. This is unnecessary but works anyway. For simplicity, dial hash keys by accessing them as if HashDialler were a Hash.
-    #
-    def to_dial(*lookup)
-        return HashDialler.new(self, *lookup)
-    end
-
-    alias_method :dial, :to_dial
-
-    # Called directly on a Hash, immediately dials and calls the hash keys specified as arguments. Returns the value found, or nil.
-    #
-    # @param lookup The hash keys to attempt to retrieve.
-    #
-    def call(*lookup)
-        return HashDialler.new(self, *lookup).call
-    end
-
-end
-
-# Extend core class so that hash.dial can be called
-class Hash
-    include HashDial
-end
+require "hash_dial/version"
+require "hash_dial/hash_dialler"
+
+module HashDial
+
+    # Called on a Hash, returns a HashDialler object for that Hash.
+    #
+    # @param lookup Parameters to this method form initial hash keys to dial. This is unnecessary but works anyway. For simplicity, dial hash keys by accessing them as if HashDialler were a Hash.
+    #
+    def to_dial(*lookup)
+        return HashDialler.new(self, *lookup)
+    end
+
+    alias_method :dial, :to_dial
+
+    # Called directly on a Hash, immediately dials and calls the hash keys specified as arguments. Returns the value found, or nil.
+    #
+    # @param lookup The hash keys to attempt to retrieve.
+    #
+    def call(*lookup)
+        return HashDialler.new(self, *lookup).call
+    end
+
+end
+
+# Extend core class so that hash.dial can be called
+class Hash
+    include HashDial
+end
+
+warn "[DEPRECATION] HashDial has been deprecated and replaced by KeyDial. Please require 'key_dial' instead (this will not break any code)."

data/lib/hash_dial/hash_dialler.rb

@@ -1,76 +1,76 @@
-module HashDial
-
-	class HashDialler
-
-		@hash
-		@lookup
-		@default = nil
-
-		def initialize(hash, *lookup)
-			if hash.is_a?(Hash)
-				@hash = hash
-			else
-				@hash = {}
-			end
-			@lookup = []
-			if lookup.length > 0
-				dial!(*lookup)
-			end
-		end
-
-		# Adds a hash key to the list of nested keys to try, one level deeper.
-		#
-		# @param keys The key to add. Multiple arguments would add multiple keys.
-		#
-		def dial!(*keys)
-			#unless key.is_a(Symbol) || key.is_a(String)
-			@lookup += keys
-			return self
-		end
-
-		# Digs into the hash to the list of keys specified by dialling. Returns nil or default if specified.
-		#
-		# @param default What to return if no key is found.
-		#
-		def call(default = nil)
-			begin
-				value = @hash.dig(*@lookup)
-			rescue
-				value = default
-			end
-			return value
-		end
-
-		# Return the original hash object.
-		def hangup
-			return @hash
-		end
-
-		# Remove keys from the dialling list.
-		#
-		# @param keys If specified, these keys would be removed from wherever they appear in the dialling list. Otherwise, the last added key is removed.
-		#
-		def undial!(*keys)
-			if keys.length > 0
-				@lookup -= keys
-			elsif @lookup.length > 0
-				@lookup.pop
-			end
-			return self
-		end
-
-		# The preferred way to build up your dialling list. Access HashDialler as if it were a Hash, e.g. hash[a][b][c]. This does not actually return any value, rather it dials those keys (awaiting a call).
-		#
-		def [](key)
-			return dial!(key)
-		end
-		def +(key)
-			return dial!(key)
-		end
-		def -(key)
-			return undial!(key)
-		end
-
-	end
-
-end
+module HashDial
+
+	class HashDialler
+
+		@hash
+		@lookup
+		@default = nil
+
+		def initialize(hash, *lookup)
+			if hash.is_a?(Hash)
+				@hash = hash
+			else
+				@hash = {}
+			end
+			@lookup = []
+			if lookup.length > 0
+				dial!(*lookup)
+			end
+		end
+
+		# Adds a hash key to the list of nested keys to try, one level deeper.
+		#
+		# @param keys The key to add. Multiple arguments would add multiple keys.
+		#
+		def dial!(*keys)
+			#unless key.is_a(Symbol) || key.is_a(String)
+			@lookup += keys
+			return self
+		end
+
+		# Digs into the hash to the list of keys specified by dialling. Returns nil or default if specified.
+		#
+		# @param default What to return if no key is found.
+		#
+		def call(default = nil)
+			begin
+				value = @hash.dig(*@lookup)
+			rescue
+				value = default
+			end
+			return value
+		end
+
+		# Return the original hash object.
+		def hangup
+			return @hash
+		end
+
+		# Remove keys from the dialling list.
+		#
+		# @param keys If specified, these keys would be removed from wherever they appear in the dialling list. Otherwise, the last added key is removed.
+		#
+		def undial!(*keys)
+			if keys.length > 0
+				@lookup -= keys
+			elsif @lookup.length > 0
+				@lookup.pop
+			end
+			return self
+		end
+
+		# The preferred way to build up your dialling list. Access HashDialler as if it were a Hash, e.g. hash[a][b][c]. This does not actually return any value, rather it dials those keys (awaiting a call).
+		#
+		def [](key)
+			return dial!(key)
+		end
+		def +(key)
+			return dial!(key)
+		end
+		def -(key)
+			return undial!(key)
+		end
+
+	end
+
+end

data/lib/hash_dial/version.rb

@@ -1,3 +1,3 @@
 module HashDial
-  VERSION = "1.0.1"
+  VERSION = "1.0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_dial
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Convincible
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-08 00:00:00.000000000 Z
+date: 2019-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,11 +52,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: 'Avoid all errors when accessing (deeply nested) Hash keys. Safer than
+description: Avoid all errors when accessing (deeply nested) Hash keys. Safer than
   dig(), as will quietly return nil (or your default) if the keys requested are invalid
-  for any reason at all. Bonus: you don''t even need to fiddle with existing code.
-  If you have already written something to access a deep hash key (e.g. hash[:a][:b][:c]),
-  just surround this with ''.dial'' and ''.call''.'
+  for any reason at all. This gem is deprecated - use KeyDial instead, which does
+  the same thing but works on Hashes, Arrays and Structs as well.
 email:
 - development@convincible.media
 executables: []
@@ -79,13 +78,13 @@ files:
 homepage: https://github.com/ConvincibleMedia/ruby-gem-hash_dial
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message: The 'hash_dial' gem has been deprecated and replaced by 'key_dial'.
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
@@ -98,5 +97,5 @@ rubygems_version: 3.0.0
 signing_key: 
 specification_version: 4
 summary: Access (deeply nested) hash keys. Get the value, or nil on any error. (Even
-  safer than Hash::dig).
+  safer than Hash::dig). Deprecated - use KeyDial.
 test_files: []