puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/lib/puppet/util/windows/security.rb

@@ -180,26 +180,6 @@ module Puppet::Util::Windows::Security
     supported
   end
 
-  def get_attributes(path)
-    Puppet.deprecation_warning('Puppet::Util::Windows::Security.get_attributes is deprecated; please use Puppet::Util::Windows::File.get_attributes')
-    FILE.get_attributes(file_name)
-  end
-
-  def add_attributes(path, flags)
-    Puppet.deprecation_warning('Puppet::Util::Windows::Security.add_attributes is deprecated; please use Puppet::Util::Windows::File.add_attributes')
-    FILE.add_attributes(path, flags)
-  end
-
-  def remove_attributes(path, flags)
-    Puppet.deprecation_warning('Puppet::Util::Windows::Security.remove_attributes is deprecated; please use Puppet::Util::Windows::File.remove_attributes')
-    FILE.remove_attributes(path, flags)
-  end
-
-  def set_attributes(path, flags)
-    Puppet.deprecation_warning('Puppet::Util::Windows::Security.set_attributes is deprecated; please use Puppet::Util::Windows::File.set_attributes')
-    FILE.set_attributes(path, flags)
-  end
-
   MASK_TO_MODE = {
     FILE::FILE_GENERIC_READ => S_IROTH,
     FILE::FILE_GENERIC_WRITE => S_IWOTH,
@@ -372,10 +352,7 @@ module Puppet::Util::Windows::Security
     dacl.allow(well_known_nobody_sid, nobody_allow)
 
     # TODO: system should be first?
-    flags = !isdir ? 0 :
-      Puppet::Util::Windows::AccessControlEntry::CONTAINER_INHERIT_ACE |
-      Puppet::Util::Windows::AccessControlEntry::OBJECT_INHERIT_ACE
-    dacl.allow(well_known_system_sid, system_allow, flags)
+    dacl.allow(well_known_system_sid, system_allow)
 
     # add inherit-only aces for child dirs and files that are created within the dir
     inherit_only = Puppet::Util::Windows::AccessControlEntry::INHERIT_ONLY_ACE
@@ -549,15 +526,6 @@ module Puppet::Util::Windows::Security
     true
   end
 
-  def with_process_token(access, &block)
-    Puppet.deprecation_warning('Puppet::Util::Windows::Security.with_process_token is deprecated; please use Puppet::Util::Windows::Process.with_process_token')
-    Puppet::Util::Windows::Process.with_process_token(access) do |token|
-      yield token
-    end
-
-    nil
-  end
-
   def get_security_descriptor(path)
     sd = nil
 
@@ -668,41 +636,6 @@ module Puppet::Util::Windows::Security
         end
       end
     end
-
-    def name_to_sid(name)
-      Puppet.deprecation_warning('Puppet::Util::Windows::Security.name_to_sid is deprecated; please use Puppet::Util::Windows::SID.name_to_sid')
-      Puppet::Util::Windows::SID.name_to_sid(name)
-    end
-
-    def name_to_sid_object(name)
-      Puppet.deprecation_warning('Puppet::Util::Windows::Security.name_to_sid_object is deprecated; please use Puppet::Util::Windows::SID.name_to_sid_object')
-      Puppet::Util::Windows::SID.name_to_sid_object(name)
-    end
-
-    def octet_string_to_sid_object(bytes)
-      Puppet.deprecation_warning('Puppet::Util::Windows::Security.octet_string_to_sid_object is deprecated; please use Puppet::Util::Windows::SID.octet_string_to_sid_object')
-      Puppet::Util::Windows::SID.octet_string_to_sid_object(bytes)
-    end
-
-    def sid_to_name(value)
-      Puppet.deprecation_warning('Puppet::Util::Windows::Security.sid_to_name is deprecated; please use Puppet::Util::Windows::SID.sid_to_name')
-      Puppet::Util::Windows::SID.sid_to_name(value)
-    end
-
-    def sid_ptr_to_string(psid)
-      Puppet.deprecation_warning('Puppet::Util::Windows::Security.sid_ptr_to_string is deprecated; please use Puppet::Util::Windows::SID.sid_ptr_to_string')
-      Puppet::Util::Windows::SID.sid_ptr_to_string(psid)
-    end
-
-    def string_to_sid_ptr(string_sid, &block)
-      Puppet.deprecation_warning('Puppet::Util::Windows::Security.string_to_sid_ptr is deprecated; please use Puppet::Util::Windows::SID.string_to_sid_ptr')
-      Puppet::Util::Windows::SID.string_to_sid_ptr(string_sid, &block)
-    end
-
-    def valid_sid?(string_sid)
-      Puppet.deprecation_warning('Puppet::Util::Windows::Security.valid_sid? is deprecated; please use Puppet::Util::Windows::SID.valid_sid?')
-      Puppet::Util::Windows::SID.valid_sid?(string_sid)
-    end
   end
 
   ffi_convention :stdcall

data/lib/puppet/util/windows/taskscheduler.rb

@@ -555,27 +555,6 @@ module Win32
       count
     end
 
-    # Returns a string that describes the current trigger at the specified
-    # index for the active task.
-    #
-    # Example: "At 7:14 AM every day, starting 4/11/2009"
-    #
-    def trigger_string(index)
-      raise Error.new('No current task scheduler. ITaskScheduler is NULL.') if @pITS.nil?
-      raise Error.new('No currently active task. ITask is NULL.') if @pITask.nil?
-      raise TypeError unless index.is_a?(Numeric)
-
-      FFI::MemoryPointer.new(:pointer) do |ptr|
-        @pITask.GetTriggerString(index, ptr)
-
-        ptr.read_com_memory_pointer do |str_ptr|
-          trigger = str_ptr.read_arbitrary_wide_string_up_to(256)
-        end
-      end
-
-      trigger
-    end
-
     # Deletes the trigger at the specified index.
     #
     def delete_trigger(index)

data/lib/puppet/util/windows/user.rb

@@ -8,11 +8,10 @@ module Puppet::Util::Windows::User
   extend FFI::Library
 
   def admin?
-    majversion = Facter.value(:kernelmajversion)
-    return false unless majversion
+    elevated_supported = Puppet::Util::Windows::Process.supports_elevated_security?
 
     # if Vista or later, check for unrestricted process token
-    return Puppet::Util::Windows::Process.elevated_security? unless majversion.to_f < 6.0
+    return Puppet::Util::Windows::Process.elevated_security? if elevated_supported
 
     # otherwise 2003 or less
     check_token_membership

data/lib/puppet/vendor/deep_merge/CHANGELOG

@@ -0,0 +1,45 @@
+2014-01-21 Dan DeLeo <dan@kallistec.com>
+  * Update knockout behavior to better handle nil (b7de40b5)
+
+2011-08-15 Dan DeLeo <dan@kallistec.com>
+  * Document how to use w/ Rails 3 via Bundler
+
+2011-07-28 Dan DeLeo <dan@kallistec.com>
+  * Use a plain ol' gemspec and Rakefile for gem creation
+
+  * Ship version 1.0.0
+
+2011-05-23  Joe Van Dyk <joe@fixieconsulting.com>
+
+  * Added Changelog
+
+2011-05-18  Joe Van Dyk <joe@fixieconsulting.com>
+
+  * Merging empty strings should work if String#blank? is defined.
+
+  * Use unix line endings
+
+  * Removing extra whitespace
+
+2010-01-11  Dan DeLeo <dan@kallistec.com>
+
+  * fix boolean merging according to mdkent's patch explicitly test 
+    for nils w/ #nil? instead of negating. Thanks mdkent!
+
+2009-12-25  Dan DeLeo <dan@kallistec.com>
+
+  * miscellaneous cleanup
+
+  * make rails/active_support compat optional
+
+  * add jeweler rake task for gemability
+
+2009-12-24  Dan DeLeo <dan@kallistec.com>
+
+  * VERSION: Version bump to 0.0.1
+
+  * VERSION: Version bump to 0.0.0
+
+2009-11-06  Jonathan Weiss <jw@innerewut.de>
+
+  * import

data/lib/puppet/vendor/deep_merge/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/lib/puppet/vendor/deep_merge/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2008-2104 Steve Midgley, Daniel DeLeo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/lib/puppet/vendor/deep_merge/README.md

@@ -0,0 +1,113 @@
+DeepMerge Overview
+==================
+
+Deep Merge is a simple set of utility functions for Hash. It permits you to merge elements inside a hash together recursively. The manner by which it does this is somewhat arbitrary (since there is no defining standard for this) but it should end up being pretty intuitive and do what you expect.
+
+You can learn a lot more about this by reading the test file. It's pretty well documented and has many examples of various merges from very simple to pretty complex.
+
+The primary need that caused me to write this library is the merging of elements coming from HTTP parameters and related stored parameters in session. This lets a user build up a set of parameters over time, modifying individual items.
+
+Deep Merge Core Documentation
+=============================
+
+`deep_merge!` method permits merging of arbitrary child elements. The two top level elements must be hashes. These hashes can contain unlimited (to stack limit) levels of child elements. These child elements to not have to be of the same types. Where child elements are of the same type, `deep_merge` will attempt to merge them together. Where child elements are not of the same type, `deep_merge` will skip or optionally overwrite the destination element with the contents of the source element at that level. So if you have two hashes like this:
+
+    source = {:x => [1,2,3], :y => 2}
+    dest =   {:x => [4,5,'6'], :y => [7,8,9]}
+    dest.deep_merge!(source)
+    Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+
+By default, `deep_merge!` will overwrite any unmergeables and merge everything else. To avoid this, use `deep_merge` (no bang/exclamation mark)
+
+Options
+-------
+
+Options are specified in the last parameter passed, which should be in hash format:
+
+    hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
+    :preserve_unmergeables  DEFAULT: false
+      Set to true to skip any unmergeable elements from source
+    :knockout_prefix        DEFAULT: nil
+      Set to string value to signify prefix which deletes elements from existing element
+    :sort_merged_arrays     DEFAULT: false
+      Set to true to sort all arrays that are merged together
+    :unpack_arrays          DEFAULT: nil
+      Set to string value to run "Array::join" then "String::split" against all arrays
+    :merge_hash_arrays      DEFAULT: false
+      Set to true to merge hashes within arrays
+    :merge_debug            DEFAULT: false
+      Set to true to get console output of merge process for debugging
+
+Selected Options Details
+------------------------
+
+**:knockout_prefix**
+
+The purpose of this is to provide a way to remove elements from existing Hash by specifying them in a special way in incoming hash
+
+    source = {:x => ['--1', '2']}
+    dest   = {:x => ['1', '3']}
+    dest.ko_deep_merge!(source)
+    Results: {:x => ['2','3']}
+
+Additionally, if the knockout_prefix is passed alone as a string, it will cause the entire element to be removed:
+
+    source = {:x => '--'}
+    dest   = {:x => [1,2,3]}
+    dest.ko_deep_merge!(source)
+    Results: {:x => ""}
+
+**:unpack_arrays**
+
+The purpose of this is to permit compound elements to be passed in as strings and to be converted into discrete array elements
+
+    irsource = {:x => ['1,2,3', '4']}
+    dest   = {:x => ['5','6','7,8']}
+    dest.deep_merge!(source, {:unpack_arrays => ','})
+    Results: {:x => ['1','2','3','4','5','6','7','8'}
+
+Why: If receiving data from an HTML form, this makes it easy for a checkbox to pass multiple values from within a single HTML element
+
+**:merge_hash_arrays**
+
+merge hashes within arrays
+
+    source = {:x => [{:y => 1}]}
+    dest   = {:x => [{:z => 2}]}
+    dest.deep_merge!(source, {:merge_hash_arrays => true})
+    Results: {:x => [{:y => 1, :z => 2}]}
+
+There are many tests for this library - and you can learn more about the features and usages of deep_merge! by just browsing the test examples.
+
+Using deep_merge in Rails
+=========================
+
+To avoid conflict with ActiveSupport, load deep_merge via:
+
+    require 'deep_merge/rails_compat'
+
+In a Gemfile:
+
+    gem "deep_merge", :require => 'deep_merge/rails_compat'
+
+The deep_merge methods will then be defined as
+
+    Hash#deeper_merge
+    Hash#deeper_merge!
+    Hash#ko_deeper_merge!
+
+Simple Example Code
+===================
+
+    require 'deep_merge'
+    x = {:x => [3,4,5]}
+    y = {:x => [1,2,3]}
+    y.deep_merge!(x)
+    # results: y = {:x => [1,2,3,4,5]}
+
+Availablility
+=============
+
+`deep_merge` was written by Steve Midgley, and is now maintained by Daniel DeLeo. The official home of `deep_merge` on the internet is now https://github.com/danielsdeleo/deep_merge
+
+Copyright (c) 2008 Steve Midgley, released under the MIT license

data/lib/puppet/vendor/deep_merge/Rakefile

@@ -0,0 +1,19 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << FileList['lib/**.rb']
+  t.test_files = FileList['test/test*.rb']
+end
+
+task :default => :test
+
+begin
+  require 'rubygems'
+  require 'rubygems/package_task'
+
+  gemspec = eval(IO.read('deep_merge.gemspec'))
+  Gem::PackageTask.new(gemspec).define
+rescue LoadError
+  #okay, then
+end
+

data/lib/puppet/vendor/deep_merge/deep_merge.gemspec

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{deep_merge}
+  s.version = "1.0.1"
+
+  s.authors = ["Steve Midgley"]
+  s.date = %q{2011-07-28}
+  s.description = %q{Recursively merge hashes. Now works with Ruby 1.9 and ActiveSupport}
+  s.email = %q{dan@kallistec.com}
+  s.license = 'MIT'
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "CHANGELOG",
+    "README.md",
+    "Rakefile",
+    "lib/deep_merge.rb",
+    "lib/deep_merge/core.rb",
+    "lib/deep_merge/deep_merge_hash.rb",
+    "lib/deep_merge/rails_compat.rb",
+    "test/test_deep_merge.rb"
+  ]
+  s.homepage = %q{http://github.com/danielsdeleo/deep_merge}
+  s.require_paths = ["lib"]
+  s.summary = %q{Merge Deeply Nested Hashes}
+  s.test_files = [
+    "test/test_deep_merge.rb"
+  ]
+
+  s.add_development_dependency "rake", "~> 10.1"
+
+end
+

data/lib/puppet/vendor/deep_merge/lib/deep_merge.rb

@@ -0,0 +1,2 @@
+require 'deep_merge/core'
+require 'deep_merge/deep_merge_hash'

data/lib/puppet/vendor/deep_merge/lib/deep_merge/core.rb

@@ -0,0 +1,210 @@
+module DeepMerge
+
+  class InvalidParameter < StandardError; end
+
+  DEFAULT_FIELD_KNOCKOUT_PREFIX = '--'
+
+  # Deep Merge core documentation.
+  # deep_merge! method permits merging of arbitrary child elements. The two top level
+  # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
+  # of child elements. These child elements to not have to be of the same types.
+  # Where child elements are of the same type, deep_merge will attempt to merge them together.
+  # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
+  # the destination element with the contents of the source element at that level.
+  # So if you have two hashes like this:
+  #   source = {:x => [1,2,3], :y => 2}
+  #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
+  #   dest.deep_merge!(source)
+  #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
+  # By default, "deep_merge!" will overwrite any unmergeables and merge everything else.
+  # To avoid this, use "deep_merge" (no bang/exclamation mark)
+  #
+  # Options:
+  #   Options are specified in the last parameter passed, which should be in hash format:
+  #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
+  #   :preserve_unmergeables  DEFAULT: false
+  #      Set to true to skip any unmergeable elements from source
+  #   :knockout_prefix        DEFAULT: nil
+  #      Set to string value to signify prefix which deletes elements from existing element
+  #   :sort_merged_arrays     DEFAULT: false
+  #      Set to true to sort all arrays that are merged together
+  #   :unpack_arrays          DEFAULT: nil
+  #      Set to string value to run "Array::join" then "String::split" against all arrays
+  #   :merge_hash_arrays      DEFAULT: false
+  #      Set to true to merge hashes within arrays
+  #   :merge_debug            DEFAULT: false
+  #      Set to true to get console output of merge process for debugging
+  #
+  # Selected Options Details:
+  # :knockout_prefix => The purpose of this is to provide a way to remove elements
+  #   from existing Hash by specifying them in a special way in incoming hash
+  #    source = {:x => ['--1', '2']}
+  #    dest   = {:x => ['1', '3']}
+  #    dest.ko_deep_merge!(source)
+  #    Results: {:x => ['2','3']}
+  #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
+  #   the entire element to be removed:
+  #    source = {:x => '--'}
+  #    dest   = {:x => [1,2,3]}
+  #    dest.ko_deep_merge!(source)
+  #    Results: {:x => ""}
+  # :unpack_arrays => The purpose of this is to permit compound elements to be passed
+  #   in as strings and to be converted into discrete array elements
+  #   irsource = {:x => ['1,2,3', '4']}
+  #   dest   = {:x => ['5','6','7,8']}
+  #   dest.deep_merge!(source, {:unpack_arrays => ','})
+  #   Results: {:x => ['1','2','3','4','5','6','7','8'}
+  #   Why: If receiving data from an HTML form, this makes it easy for a checkbox
+  #    to pass multiple values from within a single HTML element
+  #
+  # :merge_hash_arrays => merge hashes within arrays
+  #   source = {:x => [{:y => 1}]}
+  #   dest   = {:x => [{:z => 2}]}
+  #   dest.deep_merge!(source, {:merge_hash_arrays => true})
+  #   Results: {:x => [{:y => 1, :z => 2}]}
+  # 
+  # There are many tests for this library - and you can learn more about the features
+  # and usages of deep_merge! by just browsing the test examples
+  def self.deep_merge!(source, dest, options = {})
+    # turn on this line for stdout debugging text
+    merge_debug = options[:merge_debug] || false
+    overwrite_unmergeable = !options[:preserve_unmergeables]
+    knockout_prefix = options[:knockout_prefix] || nil
+    raise InvalidParameter, "knockout_prefix cannot be an empty string in deep_merge!" if knockout_prefix == ""
+    raise InvalidParameter, "overwrite_unmergeable must be true if knockout_prefix is specified in deep_merge!" if knockout_prefix && !overwrite_unmergeable
+    # if present: we will split and join arrays on this char before merging
+    array_split_char = options[:unpack_arrays] || false
+    # request that we sort together any arrays when they are merged
+    sort_merged_arrays = options[:sort_merged_arrays] || false
+    # request that arrays of hashes are merged together
+    merge_hash_arrays = options[:merge_hash_arrays] || false
+    di = options[:debug_indent] || ''
+    # do nothing if source is nil
+    return dest if source.nil?
+    # if dest doesn't exist, then simply copy source to it
+    if !(dest) && overwrite_unmergeable
+      dest = source; return dest
+    end
+
+    puts "#{di}Source class: #{source.class.inspect} :: Dest class: #{dest.class.inspect}" if merge_debug
+    if source.kind_of?(Hash)
+      puts "#{di}Hashes: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      source.each do |src_key, src_value|
+        if dest.kind_of?(Hash)
+          puts "#{di} looping: #{src_key.inspect} => #{src_value.inspect} :: #{dest.inspect}" if merge_debug
+          if dest[src_key]
+            puts "#{di} ==>merging: #{src_key.inspect} => #{src_value.inspect} :: #{dest[src_key].inspect}" if merge_debug
+            dest[src_key] = deep_merge!(src_value, dest[src_key], options.merge(:debug_indent => di + '  '))
+          else # dest[src_key] doesn't exist so we want to create and overwrite it (but we do this via deep_merge!)
+            puts "#{di} ==>merging over: #{src_key.inspect} => #{src_value.inspect}" if merge_debug
+            # note: we rescue here b/c some classes respond to "dup" but don't implement it (Numeric, TrueClass, FalseClass, NilClass among maybe others)
+            begin
+              src_dup = src_value.dup # we dup src_value if possible because we're going to merge into it (since dest is empty)
+            rescue TypeError
+              src_dup = src_value
+            end
+            dest[src_key] = deep_merge!(src_value, src_dup, options.merge(:debug_indent => di + '  '))
+          end
+        else # dest isn't a hash, so we overwrite it completely (if permitted)
+          if overwrite_unmergeable
+            puts "#{di}  overwriting dest: #{src_key.inspect} => #{src_value.inspect} -over->  #{dest.inspect}" if merge_debug
+            dest = overwrite_unmergeables(source, dest, options)
+          end
+        end
+      end
+    elsif source.kind_of?(Array)
+      puts "#{di}Arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      # if we are instructed, join/split any source arrays before processing
+      if array_split_char
+        puts "#{di} split/join on source: #{source.inspect}" if merge_debug
+        source = source.join(array_split_char).split(array_split_char)
+        if dest.kind_of?(Array)
+          dest = dest.join(array_split_char).split(array_split_char)
+        end
+      end
+      # if there's a naked knockout_prefix in source, that means we are to truncate dest
+      if knockout_prefix && source.index(knockout_prefix)
+        dest = clear_or_nil(dest); source.delete(knockout_prefix)
+      end
+      if dest.kind_of?(Array)
+        if knockout_prefix
+          print "#{di} knocking out: " if merge_debug
+          # remove knockout prefix items from both source and dest
+          source.delete_if do |ko_item|
+            retval = false
+            item = ko_item.respond_to?(:gsub) ? ko_item.gsub(%r{^#{knockout_prefix}}, "") : ko_item
+            if item != ko_item
+              print "#{ko_item} - " if merge_debug
+              dest.delete(item)
+              dest.delete(ko_item)
+              retval = true
+            end
+            retval
+          end
+          puts if merge_debug
+        end
+        puts "#{di} merging arrays: #{source.inspect} :: #{dest.inspect}" if merge_debug
+        source_all_hashes = source.all? { |i| i.kind_of?(Hash) }
+        dest_all_hashes = dest.all? { |i| i.kind_of?(Hash) }
+        if merge_hash_arrays && source_all_hashes && dest_all_hashes
+          # merge hashes in lists
+          list = []
+          dest.each_index do |i|
+            list[i] = deep_merge!(source[i] || {}, dest[i],
+                                  options.merge(:debug_indent => di + '  '))
+          end
+          list += source[dest.count..-1] if source.count > dest.count
+          dest = list
+        else
+          dest = dest | source
+        end
+        dest.sort! if sort_merged_arrays
+      elsif overwrite_unmergeable
+        puts "#{di} overwriting dest: #{source.inspect} -over-> #{dest.inspect}" if merge_debug
+        dest = overwrite_unmergeables(source, dest, options)
+      end
+    else # src_hash is not an array or hash, so we'll have to overwrite dest
+      puts "#{di}Others: #{source.inspect} :: #{dest.inspect}" if merge_debug
+      dest = overwrite_unmergeables(source, dest, options)
+    end
+    puts "#{di}Returning #{dest.inspect}" if merge_debug
+    dest
+  end # deep_merge!
+
+  # allows deep_merge! to uniformly handle overwriting of unmergeable entities
+  def self.overwrite_unmergeables(source, dest, options)
+    merge_debug = options[:merge_debug] || false
+    overwrite_unmergeable = !options[:preserve_unmergeables]
+    knockout_prefix = options[:knockout_prefix] || false
+    di = options[:debug_indent] || ''
+    if knockout_prefix && overwrite_unmergeable
+      if source.kind_of?(String) # remove knockout string from source before overwriting dest
+        src_tmp = source.gsub(%r{^#{knockout_prefix}},"")
+      elsif source.kind_of?(Array) # remove all knockout elements before overwriting dest
+        src_tmp = source.delete_if {|ko_item| ko_item.kind_of?(String) && ko_item.match(%r{^#{knockout_prefix}}) }
+      else
+        src_tmp = source
+      end
+      if src_tmp == source # if we didn't find a knockout_prefix then we just overwrite dest
+        puts "#{di}#{src_tmp.inspect} -over-> #{dest.inspect}" if merge_debug
+        dest = src_tmp
+      else # if we do find a knockout_prefix, then we just delete dest
+        puts "#{di}\"\" -over-> #{dest.inspect}" if merge_debug
+        dest = ""
+      end
+    elsif overwrite_unmergeable
+      dest = source
+    end
+    dest
+  end
+
+  def self.clear_or_nil(obj)
+    if obj.respond_to?(:clear)
+      obj.clear
+    else
+      obj = nil
+    end
+    obj
+  end
+
+end # module DeepMerge