flatten 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2f84f65a18c10d88ff02d3253ca5fb405e2b49d
-  data.tar.gz: 018c691c87d3fbb507f0c185ca84c591f7537712
+  metadata.gz: a31b1526da6e96924870c4ae463f72b9964fe586
+  data.tar.gz: 77f462a2f917ff489e157ca33abc64051fc385b2
 SHA512:
-  metadata.gz: 12135a43237f3ee41bd1523ebce64915818117914dd29a5eedd455016c07996c75e69087cc5b3db1c9e21f0fa2ce8596747195738bdbedc2f8c314225b740827
-  data.tar.gz: ba99bfd24ed530fd1a40fe500f69f579daeacc31965c6cd2f991e7e90c78274ead1f6b8336506b3f88d44d075bff9a526acced1763a17319358427c58177dee7
+  metadata.gz: c2b683d1485f95dd7c9657aff60249857867c9465b509e9d666d341040037a8bfc919a4d500c1e77530a0e29ad3168a720a0c953413e49d24056e7b9c43e720c
+  data.tar.gz: da22f29aac628276139eef472f566b17dc5771743417464e9495d917a11248fe8a6b3b2926917d4626db770cd6a2b74ea82a969353726ea16f4aefb5c861e955

data/lib/flatten.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
 
 require 'flatten/version'
+require 'flatten/string'
+require 'flatten/hash'
 require 'flatten/utility_methods'
 require 'flatten/guard_methods'
 require 'flatten/separator'

data/lib/flatten/core_ext/kernel.rb

@@ -2,17 +2,19 @@
 
 module Kernel
 
-  # @see Flatten#smash
-  # @api public
-  def Flatten(hsh, options = {})
-    Flatten.smash(hsh, options)
-  end
-  private :Flatten
+	# @see Flatten#smash
+	# @api public
+	def Flatten(hsh, options = {})
+		Flatten.smash(hsh, options)
+	end
 
-  # @see Flatten#unsmash
-  # @api public
-  def Unflatten(hsh, options = {})
-    Flatten.unsmash(hsh, options)
-  end
-  private :Unflatten
+	private :Flatten
+
+	# @see Flatten#unsmash
+	# @api public
+	def Unflatten(hsh, options = {})
+		Flatten.unsmash(hsh, options)
+	end
+
+	private :Unflatten
 end

data/lib/flatten/deprecations.rb

@@ -3,26 +3,26 @@
 require 'set'
 
 module Flatten
-  module Deprecations
-    class << self
-      def deprecate(message, target)
-        @deprecations ||= Set.new
-        msg = "Flatten: #{message} is deprecated " +
-              "and will be removed in #{target} (at #{external_callpoint})"
-        warn(msg) if @deprecations.add?(msg)
-      end
+	module Deprecations
+		class << self
+			def deprecate(message, target)
+				@deprecations ||= Set.new
+				msg = "Flatten: #{message} is deprecated " +
+					"and will be removed in #{target} (at #{external_callpoint})"
+				warn(msg) if @deprecations.add?(msg)
+			end
 
-      private
+			private
 
-      def external_callpoint
-        caller.drop_while { |loc| loc['lib/flatten/'] }.first
-      end
-    end
+			def external_callpoint
+				caller.drop_while { |loc| loc['lib/flatten/'] }.first
+			end
+		end
 
-    private
+		private
 
-    def deprecate(message, target)
-      Deprecations.deprecate(message, target)
-    end
-  end
+		def deprecate(message, target)
+			Deprecations.deprecate(message, target)
+		end
+	end
 end

data/lib/flatten/guard_methods.rb

@@ -1,24 +1,24 @@
 # encoding: utf-8
 
 module Flatten
-  # Methods to ensure Flatten isn't mixed into nonsensical things
-  module GuardMethods
-    # Flatten can be *extended* into instances of Hash
-    # @param base [Hash]
-    def extended(base)
-      unless base.is_a? Hash
-        raise ArgumentError, "<#{base.inspect}> is not a Hash!"
-      end
-    end
+	# Methods to ensure Flatten isn't mixed into nonsensical things
+	module GuardMethods
+		# Flatten can be *extended* into instances of Hash
+		# @param base [Hash]
+		def extended(base)
+			unless base.is_a? Hash
+				raise ArgumentError, "<#{base.inspect}> is not a Hash!"
+			end
+		end
 
-    # Sparsigy can be *included* into implementations of Hash
-    # @param base [Hash.class]
-    def included(base)
-      unless base <= Hash
-        raise ArgumentError, "<#{base.inspect} does not inherit Hash"
-      end
-    end
-  end
+		# Sparsigy can be *included* into implementations of Hash
+		# @param base [Hash.class]
+		def included(base)
+			unless base <= Hash
+				raise ArgumentError, "<#{base.inspect} does not inherit Hash"
+			end
+		end
+	end
 
-  extend GuardMethods
+	extend GuardMethods
 end

data/lib/flatten/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+	def smash
+		Flatten(self)
+	end
+end

data/lib/flatten/separator.rb

@@ -3,73 +3,73 @@
 require 'flatten/deprecations'
 
 module Flatten
-  # Container for a separator and functionality for splitting &
-  # joining with proper escaping.
-  # @api private
-  class Separator
-    include Deprecations
+	# Container for a separator and functionality for splitting &
+	# joining with proper escaping.
+	# @api private
+	class Separator
+		include Deprecations
 
-    @separators = {}
+		@separators = {}
 
-    # Returns a memoized Separator object for the given separator_character
-    # Evicts a member at random if memoized pool grows beyond 100.
-    #
-    # @param separator_character [String] (see #initialize)
-    def self.[](separator_character)
-      @separators[separator_character] ||= begin
-        @separators.delete(@separators.keys.sample) if @separators.size > 100
-        new(separator_character)
-      end
-    end
+		# Returns a memoized Separator object for the given separator_character
+		# Evicts a member at random if memoized pool grows beyond 100.
+		#
+		# @param separator_character [String] (see #initialize)
+		def self.[](separator_character)
+			@separators[separator_character] ||= begin
+				@separators.delete(@separators.keys.sample) if @separators.size > 100
+				new(separator_character)
+			end
+		end
 
-    # @param separator [String] single-character string
-    def initialize(separator)
-      unless separator.kind_of?(String) && separator.size > 0
-        fail ArgumentError, "separator must be a non-empty String " +
-                            "got #{separator.inspect}"
-      end
-      deprecate('multi-character separator', '2.0') unless separator.size == 1
-      @separator = separator
-    end
+		# @param separator [String] single-character string
+		def initialize(separator)
+			unless separator.kind_of?(String) && separator.size > 0
+				fail ArgumentError, "separator must be a non-empty String " +
+					"got #{separator.inspect}"
+			end
+			deprecate('multi-character separator', '2.0') unless separator.size == 1
+			@separator = separator
+		end
 
-    # Joins a pre-escaped string with a not-yet escaped string on our separator,
-    # escaping the new part before joining.
-    # @param pre_escaped_prefix [String]
-    # @param new_part [String] - will be escaped before joining
-    # @return [String]
-    def join(pre_escaped_prefix, new_part)
-      [pre_escaped_prefix, escape(new_part)].compact.join(@separator)
-    end
+		# Joins a pre-escaped string with a not-yet escaped string on our separator,
+		# escaping the new part before joining.
+		# @param pre_escaped_prefix [String]
+		# @param new_part [String] - will be escaped before joining
+		# @return [String]
+		def join(pre_escaped_prefix, new_part)
+			[pre_escaped_prefix, escape(new_part)].compact.join(@separator)
+		end
 
-    # Splits a string by our separator into non-escaped parts
-    # @param str [String]
-    # @return [Array<String>]
-    def split(str)
-      @unescaped_separator ||= /(?<!\\)(#{Regexp.escape(@separator)})/
-      # String#split(<Regexp>) on non zero-width matches yields the match
-      # as the even entries in the array.
-      parts = str.split(@unescaped_separator).each_slice(2).map(&:first)
-      parts.map do |part|
-        unescape(part)
-      end
-    end
+		# Splits a string by our separator into non-escaped parts
+		# @param str [String]
+		# @return [Array<String>]
+		def split(str)
+			@unescaped_separator ||= /(?<!\\)(#{Regexp.escape(@separator)})/
+			# String#split(<Regexp>) on non zero-width matches yields the match
+			# as the even entries in the array.
+			parts = str.split(@unescaped_separator).each_slice(2).map(&:first)
+			parts.map do |part|
+				unescape(part)
+			end
+		end
 
-    private
+		private
 
-    # backslash-escapes our separator and backlashes in a string
-    # @param str [String]
-    # @return [String]
-    def escape(str)
-      @escape_pattern ||= /(\\|#{Regexp.escape(@separator)})/
-      str.gsub(@escape_pattern, '\\\\\1')
-    end
+		# backslash-escapes our separator and backlashes in a string
+		# @param str [String]
+		# @return [String]
+		def escape(str)
+			@escape_pattern ||= /(\\|#{Regexp.escape(@separator)})/
+			str.gsub(@escape_pattern, '\\\\\1')
+		end
 
-    # removes backslash-escaping of our separator and backslashes from a string
-    # @param str [String]
-    # @return [String]
-    def unescape(str)
-      @unescape_pattern ||= /\\(\\|#{Regexp.escape(@separator)})/
-      str.gsub(@unescape_pattern, '\1')
-    end
-  end
+		# removes backslash-escaping of our separator and backslashes from a string
+		# @param str [String]
+		# @return [String]
+		def unescape(str)
+			@unescape_pattern ||= /\\(\\|#{Regexp.escape(@separator)})/
+			str.gsub(@unescape_pattern, '\1')
+		end
+	end
 end

data/lib/flatten/string.rb

@@ -0,0 +1,5 @@
+class String
+	def smash
+		Flatten(JSON.parse(self)).to_json
+	end
+end

data/lib/flatten/utility_methods.rb

@@ -1,201 +1,208 @@
 # encoding: utf-8
 
 module Flatten
-  # The Utility Methods provide a significant (~4x) performance increase
-  # over extend-ing instance methods everywhere we need them.
-  module UtilityMethods
-
-    # Provides a way to iterate through a deeply-nested hash as if it were
-    # a smash-hash. Used internally for generating and deconstructing smash
-    # hashes.
-    #
-    # @overload smash_each(hsh, options = {}, &block)
-    #   Yields once per key in smash version of itself.
-    #   @param hsh [Hash<#to_s,Object>]
-    #   @param options (see Flatten::UtilityMethods#smash)
-    #   @yieldparam [(smash_key,value)]
-    #   @return [void]
-    # @overload smash_each(hsh, options = {})
-    #   @param hsh [Hash<#to_s,Object>]
-    #   @param options (see Flatten::UtilityMethods#smash)
-    #   @return [Enumerator<(smash_key,value)>]
-    def smash_each(hsh, options = {}, &block)
-      return enum_for(:smash_each, hsh, options) unless block_given?
-
-      inherited_prefix = options.fetch(:prefix, nil)
-      separator = options.fetch(:separator, DEFAULT_SEPARATOR)
-      smash_array = options.fetch(:smash_array, false)
-
-      hsh.each do |partial_key, value|
-        key = escaped_join(inherited_prefix, partial_key.to_s, separator)
-        if value.kind_of?(Hash) && !value.empty?
-          smash_each(value, options.merge(prefix: key), &block)
-        elsif smash_array && value.kind_of?(Array) && !value.empty?
-          zps = (smash_array == :zero_pad ? "%0#{value.count.to_s.size}d" : '%d')# zero-pad string
-          smash_each(value.count.times.map(&zps.method(:%)).zip(value), options.merge(prefix: key), &block)
-        else
-          yield key, value
-        end
-      end
-    end
-
-    # Returns a smash version of the given hash
-    #
-    # @param hsh [Hash<#to_s,Object>]
-    # @param options (see Flatten::UtilityMethods#smash)
-    # @return [Hash<String,Object>]
-    def smash(hsh, options = {})
-      enum = smash_each(hsh, options)
-      enum.each_with_object(Hash.new) do |(key, value), memo|
-        memo[key] = value
-      end
-    end
-
-    # Returns a deeply-nested version of the given smash hash
-    # @param hsh [Hash<#to_s,Object>]
-    # @param options (see Flatten::UtilityMethods#smash)
-    # @return [Hash<String,Object>]
-    def unsmash(hsh, options = {})
-      separator = options.fetch(:separator, DEFAULT_SEPARATOR)
-      hsh.each_with_object({}) do |(k, v), memo|
-        current = memo
-        key = escaped_split(k, separator)
-        puts "key: #{key}"
-        up_next = partial = key.shift
-        until key.size.zero?
-          up_next = key.shift
-          up_next = up_next.to_i if (up_next =~ /\A[0-9]+\Z/)
-          current = (current[partial] ||= (up_next.kind_of?(Integer) ? [] : {}))
-          case up_next
-          when Integer then raise KeyError unless current.kind_of?(Array)
-          else              raise KeyError unless current.kind_of?(Hash)
-          end
-          partial = up_next
-        end
-        current[up_next] = v
-      end
-    end
-
-    # Fetch a smash key from the given deeply-nested hash.
-    #
-    # @overload smash_fetch(hsh, smash_key, default, options = {})
-    #   @param hsh [Hash<#to_s,Object>]
-    #   @param smash_key [#to_s]
-    #   @param default [Object] returned if smash key not found
-    #   @param options (see Flatten::UtilityMethods#smash)
-    #   @return [Object]
-    # @overload smash_fetch(hsh, smash_key, options = {}, &block)
-    #   @param hsh [Hash<#to_s,Object>]
-    #   @param smash_key [#to_s]
-    #   @param options (see Flatten::UtilityMethods#smash)
-    #   @yieldreturn is returned if key not found
-    #   @return [Object]
-    # @overload smash_fetch(hsh, smash_key, options = {})
-    #   @param hsh [Hash<#to_s,Object>]
-    #   @param smash_key [#to_s]
-    #   @param options (see Flatten::UtilityMethods#smash)
-    #   @raise KeyError if key not found
-    #   @return [Object]
-    def smash_fetch(hsh, smash_key, *args, &block)
-      options = ( args.last.kind_of?(Hash) ? args.pop : {})
-      default = args.pop
-
-      separator = options.fetch(:separator, DEFAULT_SEPARATOR)
-
-      escaped_split(smash_key, separator).reduce(hsh) do |memo, kp|
-        if memo.kind_of?(Hash) and memo.has_key?(kp)
-          memo.fetch(kp)
-        elsif default
-          return default
-        elsif block_given?
-          return yield
-        else
-          raise KeyError, smash_key
-        end
-      end
-    end
-
-    # Get a smash key from the given deeply-nested hash, or return nil
-    # if key not found.
-    #
-    # Worth noting is that Hash#default_proc is *not* used, as the intricacies
-    # of implementation would lead to all sorts of terrible surprises.
-    #
-    # @param hsh [Hash<#to_s,Object>]
-    # @param smash_key [#to_s]
-    # @param options (see Flatten::UtilityMethods#smash)
-    # @return [Object]
-    def smash_get(hsh, smash_key, options = {})
-      smash_fetch(hsh, smash_key, options) { nil }
-    end
-
-    # Given a smash hash, unflatten a subset by address, returning
-    # a *modified copy* of the original smash hash.
-    #
-    # @overload expand(smash_hsh, smash_key, options = {}, &block)
-    #   @param smash_hsh [Hash{String=>Object}]
-    #   @param smash_key [String]
-    #   @param options (see Flatten::UtilityMethods#smash)
-    #   @return [Object]
-    #
-    # @example
-    # ~~~ ruby
-    # smash = {'a.b' => 2, 'a.c.d' => 4, 'a.c.e' => 3, 'b.f' => 4}
-    # Flatten::expand(smash, 'a.c')
-    # # => {'a.b' => 2, 'a.c' => {'d' => 4, 'e' => 3}, 'b.f' => 4}
-    # ~~~
-    def expand(smash_hsh, smash_key, *args)
-      # if smash_hsh includes our key, its value is already expanded.
-      return smash_hsh if smash_hsh.include?(smash_key)
-
-      options = (args.last.kind_of?(Hash) ? args.pop : {})
-      separator = options.fetch(:separator, DEFAULT_SEPARATOR)
-      pattern = /\A#{Regexp.escape(smash_key)}#{Regexp.escape(separator)}/i
-
-      match = {}
-      unmatch = {}
-      smash_hsh.each do |k, v|
-        if pattern =~ k
-          sk = k.gsub(pattern, '')
-          match[sk] = v
-        else
-          unmatch[k] = v
-        end
-      end
-
-      unmatch.update(smash_key => unsmash(match, options)) unless match.empty?
-      unmatch
-    end
-
-    # Given a smash hash, unflatten a subset by address *in place*
-    # (@see Flatten::UtilityMethods#expand)
-    def expand!(smash_hsh, *args)
-      smash_hsh.replace expand(smash_hsh, *args)
-    end
-
-    private
-
-    # Utility method for splitting a string by a separator into
-    # non-escaped parts
-    # @api private
-    # @param str [String]
-    # @param separator [String] single-character string
-    # @return [Array<String>]
-    def escaped_split(str, separator)
-      Separator[separator].split(str)
-    end
-
-    # Utility method for joining a pre-escaped string with a not-yet escaped
-    # string on a given separator, escaping the new part before joining.
-    # @api private
-    # @param pre_escaped_prefix [String]
-    # @param new_part [String] - will be escaped before joining
-    # @param separator [String] single-character string
-    # @return [String]
-    def escaped_join(pre_escaped_prefix, new_part, separator)
-      Separator[separator].join(pre_escaped_prefix, new_part)
-    end
-  end
-
-  extend UtilityMethods
+	# The Utility Methods provide a significant (~4x) performance increase
+	# over extend-ing instance methods everywhere we need them.
+	module UtilityMethods
+
+		# Provides a way to iterate through a deeply-nested hash as if it were
+		# a smash-hash. Used internally for generating and deconstructing smash
+		# hashes.
+		#
+		# @overload smash_each(hsh, options = {}, &block)
+		#   Yields once per key in smash version of itself.
+		#   @param hsh [Hash<#to_s,Object>]
+		#   @param options (see Flatten::UtilityMethods#smash)
+		#   @yieldparam [(smash_key,value)]
+		#   @return [void]
+		# @overload smash_each(hsh, options = {})
+		#   @param hsh [Hash<#to_s,Object>]
+		#   @param options (see Flatten::UtilityMethods#smash)
+		#   @return [Enumerator<(smash_key,value)>]
+		def smash_each(hsh, options = {}, &block)
+			return enum_for(:smash_each, hsh, options) unless block_given?
+
+			inherited_prefix = options.fetch(:prefix, nil)
+			separator = options.fetch(:separator, DEFAULT_SEPARATOR)
+			smash_array = options.fetch(:smash_array, false)
+
+			hsh.each do |partial_key, value|
+				key = escaped_join(inherited_prefix, partial_key.to_s, separator)
+				if value.kind_of?(Hash) && !value.empty?
+					smash_each(value, options.merge(prefix: key), &block)
+				elsif smash_array && value.kind_of?(Array) && !value.empty?
+					zps = (smash_array == :zero_pad ? "%0#{value.count.to_s.size}d" : '%d') # zero-pad string
+					smash_each(value.count.times.map(&zps.method(:%)).zip(value), options.merge(prefix: key), &block)
+				else
+					yield key, value
+				end
+			end
+		end
+
+		# Returns a smash version of the given hash
+		#
+		# @param hsh [Hash<#to_s,Object>]
+		# @param options (see Flatten::UtilityMethods#smash)
+		# @return [Hash<String,Object>]
+		def smash(hsh, options = {})
+			enum = smash_each(hsh, options)
+			enum.each_with_object(Hash.new) do |(key, value), memo|
+				a = key.split('.');
+				flat_key = a[a.size - 1]
+				if flat_key
+					key = flat_key
+				end
+				memo[key] = value
+			end
+		end
+
+		# Returns a deeply-nested version of the given smash hash
+		# @param hsh [Hash<#to_s,Object>]
+		# @param options (see Flatten::UtilityMethods#smash)
+		# @return [Hash<String,Object>]
+		def unsmash(hsh, options = {})
+			separator = options.fetch(:separator, DEFAULT_SEPARATOR)
+			hsh.each_with_object({}) do |(k, v), memo|
+				current = memo
+				key = escaped_split(k, separator)
+				puts "key: #{key}"
+				up_next = partial = key.shift
+				until key.size.zero?
+					up_next = key.shift
+					up_next = up_next.to_i if (up_next =~ /\A[0-9]+\Z/)
+					current = (current[partial] ||= (up_next.kind_of?(Integer) ? [] : {}))
+					case up_next
+						when Integer then
+							raise KeyError unless current.kind_of?(Array)
+						else
+							raise KeyError unless current.kind_of?(Hash)
+					end
+					partial = up_next
+				end
+				current[up_next] = v
+			end
+		end
+
+		# Fetch a smash key from the given deeply-nested hash.
+		#
+		# @overload smash_fetch(hsh, smash_key, default, options = {})
+		#   @param hsh [Hash<#to_s,Object>]
+		#   @param smash_key [#to_s]
+		#   @param default [Object] returned if smash key not found
+		#   @param options (see Flatten::UtilityMethods#smash)
+		#   @return [Object]
+		# @overload smash_fetch(hsh, smash_key, options = {}, &block)
+		#   @param hsh [Hash<#to_s,Object>]
+		#   @param smash_key [#to_s]
+		#   @param options (see Flatten::UtilityMethods#smash)
+		#   @yieldreturn is returned if key not found
+		#   @return [Object]
+		# @overload smash_fetch(hsh, smash_key, options = {})
+		#   @param hsh [Hash<#to_s,Object>]
+		#   @param smash_key [#to_s]
+		#   @param options (see Flatten::UtilityMethods#smash)
+		#   @raise KeyError if key not found
+		#   @return [Object]
+		def smash_fetch(hsh, smash_key, *args, &block)
+			options = (args.last.kind_of?(Hash) ? args.pop : {})
+			default = args.pop
+
+			separator = options.fetch(:separator, DEFAULT_SEPARATOR)
+
+			escaped_split(smash_key, separator).reduce(hsh) do |memo, kp|
+				if memo.kind_of?(Hash) and memo.has_key?(kp)
+					memo.fetch(kp)
+				elsif default
+					return default
+				elsif block_given?
+					return yield
+				else
+					raise KeyError, smash_key
+				end
+			end
+		end
+
+		# Get a smash key from the given deeply-nested hash, or return nil
+		# if key not found.
+		#
+		# Worth noting is that Hash#default_proc is *not* used, as the intricacies
+		# of implementation would lead to all sorts of terrible surprises.
+		#
+		# @param hsh [Hash<#to_s,Object>]
+		# @param smash_key [#to_s]
+		# @param options (see Flatten::UtilityMethods#smash)
+		# @return [Object]
+		def smash_get(hsh, smash_key, options = {})
+			smash_fetch(hsh, smash_key, options) { nil }
+		end
+
+		# Given a smash hash, unflatten a subset by address, returning
+		# a *modified copy* of the original smash hash.
+		#
+		# @overload expand(smash_hsh, smash_key, options = {}, &block)
+		#   @param smash_hsh [Hash{String=>Object}]
+		#   @param smash_key [String]
+		#   @param options (see Flatten::UtilityMethods#smash)
+		#   @return [Object]
+		#
+		# @example
+		# ~~~ ruby
+		# smash = {'a.b' => 2, 'a.c.d' => 4, 'a.c.e' => 3, 'b.f' => 4}
+		# Flatten::expand(smash, 'a.c')
+		# # => {'a.b' => 2, 'a.c' => {'d' => 4, 'e' => 3}, 'b.f' => 4}
+		# ~~~
+		def expand(smash_hsh, smash_key, *args)
+			# if smash_hsh includes our key, its value is already expanded.
+			return smash_hsh if smash_hsh.include?(smash_key)
+
+			options = (args.last.kind_of?(Hash) ? args.pop : {})
+			separator = options.fetch(:separator, DEFAULT_SEPARATOR)
+			pattern = /\A#{Regexp.escape(smash_key)}#{Regexp.escape(separator)}/i
+
+			match = {}
+			unmatch = {}
+			smash_hsh.each do |k, v|
+				if pattern =~ k
+					sk = k.gsub(pattern, '')
+					match[sk] = v
+				else
+					unmatch[k] = v
+				end
+			end
+
+			unmatch.update(smash_key => unsmash(match, options)) unless match.empty?
+			unmatch
+		end
+
+		# Given a smash hash, unflatten a subset by address *in place*
+		# (@see Flatten::UtilityMethods#expand)
+		def expand!(smash_hsh, *args)
+			smash_hsh.replace expand(smash_hsh, *args)
+		end
+
+		private
+
+		# Utility method for splitting a string by a separator into
+		# non-escaped parts
+		# @api private
+		# @param str [String]
+		# @param separator [String] single-character string
+		# @return [Array<String>]
+		def escaped_split(str, separator)
+			Separator[separator].split(str)
+		end
+
+		# Utility method for joining a pre-escaped string with a not-yet escaped
+		# string on a given separator, escaping the new part before joining.
+		# @api private
+		# @param pre_escaped_prefix [String]
+		# @param new_part [String] - will be escaped before joining
+		# @param separator [String] single-character string
+		# @return [String]
+		def escaped_join(pre_escaped_prefix, new_part, separator)
+			Separator[separator].join(pre_escaped_prefix, new_part)
+		end
+	end
+
+	extend UtilityMethods
 end

data/lib/flatten/version.rb

@@ -1,3 +1,3 @@
 module Flatten
-  VERSION = "0.1.1"
+	VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flatten
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - l3x
@@ -73,7 +73,9 @@ files:
 - lib/flatten/core_ext/kernel.rb
 - lib/flatten/deprecations.rb
 - lib/flatten/guard_methods.rb
+- lib/flatten/hash.rb
 - lib/flatten/separator.rb
+- lib/flatten/string.rb
 - lib/flatten/utility_methods.rb
 - lib/flatten/version.rb
 homepage: https://github.com/l3x/flatten