key_dial 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adcb8d79a70615b55ef7096cb21d1df639a35fa8e83e42eff35e59dbfa2b466a
-  data.tar.gz: 5eed7fe134f7bf05227012c4a0242a5c89cc76d8c62afacc978ff17a1e09e76a
+  metadata.gz: 2dda856c325133404a9948a0a97d98009d5a46fdcbb916977f4b280094ff2b08
+  data.tar.gz: 387b760bf24b91add075b1c4a9a05ae01fa8fa134695bad0caf718fcbacc7d1e
 SHA512:
-  metadata.gz: 28a754fba139b866e22a2184782ceba09aaed757384b92aa3607d4f9bff0b551162818dfac4ea01919509d9625e030a2b27c33184ca8c9aa938076995e2f0613
-  data.tar.gz: cac3c202ca11e2c398d35cf89079e1ead4dc2e95e83f6aed0ea281b672f5b2916bbadd63d1241418c0f46cf757f3d6268f753f695770443873b725481a9f547f
+  metadata.gz: 45e32b32d08741ef44825ee3749fd45c29949ef35c101e8c490e1d980c7af6aea3cec12e5c443a6fbeab133aa1a11518e110ca22d5235206e215b13634cc4fd2
+  data.tar.gz: 002c925e1c2558a58d19d0ab2123f47a5d150d8ce06da692404b39fd5120e151a1834a8deb0cd198ca0fae6a9c353cba1627388d9f81d8eb2c21f7eb492708d0

data/lib/key_dial/coercion.rb

@@ -2,13 +2,30 @@ module KeyDial
 
 	module Coercion
 
-		module Hashes
-
-			# Convert a Hash to a Struct. {a: 1, b: 2, c: 3} will become <Struct :a=1, :b=2, :c=3>
-			#
-			def to_struct(type_class = nil)
-				return Coercion::Structs.create(self, type_class)
+		module Coercer
+			def to(type)
+				if type.is_a?(Class)
+					if type == self.class || self.class < type
+						return self
+					elsif (type == Hash || type < Hash) && type.respond_to?(:from)
+						return type.from(self)
+					elsif (type == Array || type < Array) && type.respond_to?(:from)
+						return type.from(self)
+					elsif (type == Struct || type < Struct) && type.respond_to?(:from)
+						return type.from(self)
+					else
+						raise ArgumentError, "Cannot coerce to " + type.to_s
+					end
+				else
+					raise ArgumentError, "Must specify a class to coerce to."
+				end
 			end
+		end
+
+		module Hashes
+			
+			# Adds .to() method to instances of this class
+			include Coercer
 
 			def self.included(base)
 			   	base.extend ClassMethods
@@ -19,10 +36,30 @@ module KeyDial
 				# Allows you to do Hash.from(obj) to create a Hash from any object intelligently.
 				#
 				def from(obj)
-					return obj if obj.is_a?(Hash)
-					return obj.to_hash if obj.is_a?(Array)
-					return obj.to_h if obj.is_a?(Struct)
-					return {0 => obj}
+					case obj
+					when Hash
+						return obj
+					when Array
+						# Hash from Array. Forgiving and avoids errors. ['a', 'b', 'c'] will become {0 => 'a', 1 => 'b', 2 => 'c'}
+						obj.each_with_index.map { |k, i|
+							if k.is_a?(Array)
+								if k.empty?
+									[i, nil]
+								elsif k.size == 2
+									k # k in this case is a keyval pair, e.g. [k, v]
+								else
+									[i, k]
+								end
+							else
+								[i, k]
+							end
+						}.to_h
+					when Struct
+						# Hash from Struct
+						return obj.to_h
+					else
+						{0 => obj}
+					end
 				end
 
 			end
@@ -31,31 +68,8 @@ module KeyDial
 
 		module Arrays
 
-			# Convert an Array to a Hash, providing an alternative to the native to_h() method. to_hash() is more forgiving and avoids errors. ['a', 'b', 'c'] will become {0 => 'a', 1 => 'b', 2 => 'c'}
-			#
-			def to_hash
-				self.each_with_index.map { |k, i|
-					if k.is_a?(Array)
-						if k.empty?
-							[i, nil]
-						elsif k.size == 2
-							k # k in this case is a keyval pair, e.g. [k, v]
-						else
-							[i, k]
-						end
-					else
-						[i, k]
-					end
-				}.to_h
-			end
-
-			# Convert an Array to a Struct. ['a', 'b', 'c'] will become <Struct :'0'='a', :'1'='b', :'2'='c'>
-			#
-			# @param type_class If a sub-class of Struct is provided, this sub-class will be instantiated
-			#
-			def to_struct(type_class = nil)
-				return Coercion::Structs.create(self, type_class)
-			end
+			# Adds .to() method to instances of this class
+			include Coercer
 
 			def self.included(base)
 			   	base.extend ClassMethods
@@ -66,10 +80,18 @@ module KeyDial
 				# Allows you to do Array.from(obj) to create an Array from any object intelligently.
 				#
 				def from(obj)
-					return obj if obj.is_a?(Array)
-					return obj.to_a if obj.is_a?(Hash)
-					return obj.to_h.to_a if obj.is_a?(Struct)
-					return [obj]
+					case obj
+					when Array
+						return obj
+					when Hash
+						# Array from Hash
+						return obj.to_a
+					when Struct
+						# Array from Struct
+						return obj.to_h.to_a
+					else
+						return [obj]
+					end
 				end
 
 			end
@@ -78,19 +100,10 @@ module KeyDial
 
 		module Structs
 
-			EMPTY = Struct.new(:'0').new.freeze
+			# Adds .to() method to instances of this class
+			include Coercer
 
-			# Convert a Struct to another Struct.
-			#
-			# @param type_class If a sub-class of Struct is provided, the Struct will be converted to this sub-class
-			#
-			def to_struct(type_class = nil)
-				if type_class.is_a?(Class) && type_class < Struct
-					return Struct.from(self, type_class)
-				else
-					return self
-				end
-			end
+			EMPTY = Struct.new(:'0').new.freeze
 
 			def self.included(base)
 			   	base.extend ClassMethods
@@ -100,86 +113,73 @@ module KeyDial
 
 				# Allows you to do Struct.from(obj) to instantiate a Struct using keys/values from any object intelligently.
 				#
-				# @param type_class If a sub-class of Struct is provided, this sub-class will be instantiated
-				#
-				def from(obj, type_class = nil)
-					if !obj.is_a?(Struct) && !obj.is_a?(Hash) && !obj.is_a?(Array) && type_class == nil
-						s = EMPTY.dup
-						s[0] = obj
-						return s
-					else
-						return Coercion::Structs.create(obj, type_class)
-					end
-				end
-
-			end
-
-			# Struct creation function not really meant to be used directly. Prefer Struct.from(obj).
-			#
-			# @param from_obj Keys/values from this object will be used to fill out the new Struct.
-			# @param type_class If a sub-class of Struct is provided, this sub-class will be instantiated
-			#
-			def self.create(from_obj, type_class = nil)
-				if from_obj.is_a?(Hash) || from_obj.is_a?(Array) || from_obj.is_a?(Struct)
-				 	return EMPTY.dup if from_obj.empty? && type_class == nil
-					from = from_obj
-				else
-					from = [from_obj]
-				end
-
-				# Has a specific type of Struct been specified?
-				if type_class.is_a?(Class) && type_class < Struct
-					if from.is_a?(type_class)
-						# Has an instantiation of that type of Struct been passed in? If so, just return it
-						return from
-					else
-						values = []
-						if from.is_a?(Array)
-							# Get as many elements of array as this Struct can handle - discard the rest
-							values = from.first(type_class.members.size)
-						else 
-							# Not an Array, so must be another Struct or Hash
-							type_class.members.each { |key|
-								if from.key?(key)
-									# If the object has this expected key, use it
-									values << from[key]
-								else
-									# Otherwise, fill this key with nil
-									values << nil
-									# Keys in the from object which don't match expected keys are discarded
-								end
-							}
-						end
-						# values now contains a value or nil for each of this class's expected keys
-						return type_class.new(*values)
+				def from(_obj)
+					from_obj = _obj
+					if !from_obj.is_a?(Struct) && !from_obj.is_a?(Hash) && !from_obj.is_a?(Array)
+						return EMPTY if _obj == EMPTY[0]
+						return EMPTY if _obj.nil?
+						# For non-keyed objects, we will treat the whole object like it's a value to push into the first property of a struct
+						from_obj = [_obj]
 					end
-				else
-					# Anonymous Struct
-					new_values = from.is_a?(Array) ? from : from.values
-					# Iterate over the keys of the from object
-					# (Array.keys is monkeypatched in)
-					new_keys = from.keys.each_with_index.map { |k, i|
-						if k.respond_to?(:to_sym) && k != ''
-							k.to_sym
-						elsif k.respond_to?(:to_s) && !k.nil?
-							k.to_s.to_sym
+					
+					struct_class = self
+	
+					# Are we operating on a defined type of Struct?
+					if struct_class < Struct
+						if from_obj.is_a?(struct_class)
+							# Has an instantiation of that type of Struct been passed in? If so, just return it
+							return from_obj
 						else
-							# If we can't construct a valid Struct key for this key, we discard the corresponding value
-							new_values.delete_at(i)
-							nil
+							# Get values
+							values = []
+							if from_obj.is_a?(Array)
+								# Get as many elements of array as this Struct can handle - discard the rest
+								values = from_obj.first(struct_class.members.size)
+							else 
+								# Not an Array, so must be another Struct or Hash
+								struct_class.members.each { |key|
+									if from_obj.key?(key)
+										# If the object has this expected key, use it
+										values << from_obj[key]
+									else
+										# Otherwise, fill this key with nil
+										values << nil
+										# Keys in the from object which don't match expected keys are discarded
+									end
+								}
+							end
+							# values now contains a value or nil for each of this class's expected keys
+							return struct_class.new(*values)
 						end
-					}.reject(&:nil?)
-					if new_keys.size > 0
-						# Create anonymous Struct with the specified keys and values
-						return Struct.new(*new_keys).new(*new_values)
 					else
-						# Return the Empty Struct
-						return EMPTY.dup
+						# Anonymous Struct
+						new_values = from_obj.is_a?(Array) ? from_obj : from_obj.values
+						# Iterate over the keys of the from object
+						# (Array.keys is monkeypatched in)
+						new_keys = from_obj.keys.each_with_index.map { |k, i|
+							if k.respond_to?(:to_sym) && k != ''
+								k.to_sym
+							elsif k.respond_to?(:to_s) && !k.nil?
+								k.to_s.to_sym
+							else
+								# If we can't construct a valid Struct key for this key, we discard the corresponding value
+								new_values.delete_at(i)
+								nil
+							end
+						}.reject(&:nil?)
+						if new_keys.size > 0
+							# Create anonymous Struct with the specified keys and values
+							return Struct.new(*new_keys).new(*new_values)
+						else
+							# Return the Empty Struct
+							return EMPTY
+						end
 					end
+					
+				rescue
+					return EMPTY
 				end
 
-			rescue
-				return EMPTY.dup
 			end
 
 		end

data/lib/key_dial/key_dialler.rb

@@ -380,7 +380,7 @@ module KeyDial
 						# Why would you do this?
 						deep_obj[key[:this][:value]] = Struct.from(deep_obj[key[:this][:value]])
 					elsif type_class.is_a?(Class) && type_class < Struct
-						deep_obj[key[:this][:value]] = Struct.from(deep_obj[key[:this][:value]], type_class)
+						deep_obj[key[:this][:value]] = type_class.from(deep_obj[key[:this][:value]])
 					elsif type_class == String && deep_obj[key[:this][:value]].respond_to?(:to_s)
 						deep_obj[key[:this][:value]] = deep_obj[key[:this][:value]].to_s
 					elsif type_class == Symbol

data/lib/key_dial/version.rb

@@ -1,3 +1,3 @@
 module KeyDial
-	VERSION = "1.1.0"
+	VERSION = "1.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: key_dial
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Convincible
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-25 00:00:00.000000000 Z
+date: 2019-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler