puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/util/windows/user.rb

@@ -0,0 +1,292 @@
+require 'puppet/util/windows'
+
+require 'facter'
+require 'ffi'
+
+module Puppet::Util::Windows::User
+  extend Puppet::Util::Windows::String
+  extend FFI::Library
+
+  def admin?
+    majversion = Facter.value(:kernelmajversion)
+    return false unless majversion
+
+    # if Vista or later, check for unrestricted process token
+    return Puppet::Util::Windows::Process.elevated_security? unless majversion.to_f < 6.0
+
+    # otherwise 2003 or less
+    check_token_membership
+  end
+  module_function :admin?
+
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/ee207397(v=vs.85).aspx
+  SECURITY_MAX_SID_SIZE = 68
+
+  def check_token_membership
+    is_admin = false
+    FFI::MemoryPointer.new(:byte, SECURITY_MAX_SID_SIZE) do |sid_pointer|
+      FFI::MemoryPointer.new(:dword, 1) do |size_pointer|
+        size_pointer.write_uint32(SECURITY_MAX_SID_SIZE)
+
+        if CreateWellKnownSid(:WinBuiltinAdministratorsSid, FFI::Pointer::NULL, sid_pointer, size_pointer) == FFI::WIN32_FALSE
+          raise Puppet::Util::Windows::Error.new("Failed to create administrators SID")
+        end
+      end
+
+      if IsValidSid(sid_pointer) == FFI::WIN32_FALSE
+        raise Puppet::Util::Windows::Error.new("Invalid SID")
+      end
+
+      FFI::MemoryPointer.new(:win32_bool, 1) do |ismember_pointer|
+        if CheckTokenMembership(FFI::Pointer::NULL_HANDLE, sid_pointer, ismember_pointer) == FFI::WIN32_FALSE
+          raise Puppet::Util::Windows::Error.new("Failed to check membership")
+        end
+
+        # Is administrators SID enabled in calling thread's access token?
+        is_admin = ismember_pointer.read_win32_bool != FFI::WIN32_FALSE
+      end
+    end
+
+    is_admin
+  end
+  module_function :check_token_membership
+
+  def password_is?(name, password)
+    logon_user(name, password) { |token| }
+  rescue Puppet::Util::Windows::Error
+    false
+  end
+  module_function :password_is?
+
+  def logon_user(name, password, &block)
+    fLOGON32_LOGON_NETWORK = 3
+    fLOGON32_PROVIDER_DEFAULT = 0
+
+    token = nil
+    begin
+      FFI::MemoryPointer.new(:handle, 1) do |token_pointer|
+        if LogonUserW(wide_string(name), wide_string('.'), wide_string(password),
+            fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, token_pointer) == FFI::WIN32_FALSE
+          raise Puppet::Util::Windows::Error.new("Failed to logon user #{name.inspect}")
+        end
+
+        yield token = token_pointer.read_handle
+      end
+    ensure
+      FFI::WIN32.CloseHandle(token) if token
+    end
+
+    # token has been closed by this point
+    true
+  end
+  module_function :logon_user
+
+  def load_profile(user, password)
+    logon_user(user, password) do |token|
+      FFI::MemoryPointer.from_string_to_wide_string(user) do |lpUserName|
+        pi = PROFILEINFO.new
+        pi[:dwSize] = PROFILEINFO.size
+        pi[:dwFlags] = 1 # PI_NOUI - prevents display of profile error msgs
+        pi[:lpUserName] = lpUserName
+
+        # Load the profile. Since it doesn't exist, it will be created
+        if LoadUserProfileW(token, pi.pointer) == FFI::WIN32_FALSE
+          raise Puppet::Util::Windows::Error.new("Failed to load user profile #{user.inspect}")
+        end
+
+        Puppet.debug("Loaded profile for #{user}")
+
+        if UnloadUserProfile(token, pi[:hProfile]) == FFI::WIN32_FALSE
+          raise Puppet::Util::Windows::Error.new("Failed to unload user profile #{user.inspect}")
+        end
+      end
+    end
+  end
+  module_function :load_profile
+
+  ffi_convention :stdcall
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa378184(v=vs.85).aspx
+  # BOOL LogonUser(
+  #   _In_      LPTSTR lpszUsername,
+  #   _In_opt_  LPTSTR lpszDomain,
+  #   _In_opt_  LPTSTR lpszPassword,
+  #   _In_      DWORD dwLogonType,
+  #   _In_      DWORD dwLogonProvider,
+  #   _Out_     PHANDLE phToken
+  # );
+  ffi_lib :advapi32
+  attach_function_private :LogonUserW,
+    [:lpwstr, :lpwstr, :lpwstr, :dword, :dword, :phandle], :win32_bool
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/bb773378(v=vs.85).aspx
+  # typedef struct _PROFILEINFO {
+  #   DWORD  dwSize;
+  #   DWORD  dwFlags;
+  #   LPTSTR lpUserName;
+  #   LPTSTR lpProfilePath;
+  #   LPTSTR lpDefaultPath;
+  #   LPTSTR lpServerName;
+  #   LPTSTR lpPolicyPath;
+  #   HANDLE hProfile;
+  # } PROFILEINFO, *LPPROFILEINFO;
+  # technically
+  # NOTE: that for structs, buffer_* (lptstr alias) cannot be used
+  class PROFILEINFO < FFI::Struct
+    layout :dwSize, :dword,
+           :dwFlags, :dword,
+           :lpUserName, :pointer,
+           :lpProfilePath, :pointer,
+           :lpDefaultPath, :pointer,
+           :lpServerName, :pointer,
+           :lpPolicyPath, :pointer,
+           :hProfile, :handle
+  end
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/bb762281(v=vs.85).aspx
+  # BOOL WINAPI LoadUserProfile(
+  #   _In_     HANDLE hToken,
+  #   _Inout_  LPPROFILEINFO lpProfileInfo
+  # );
+  ffi_lib :userenv
+  attach_function_private :LoadUserProfileW,
+    [:handle, :pointer], :win32_bool
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/bb762282(v=vs.85).aspx
+  # BOOL WINAPI UnloadUserProfile(
+  #   _In_  HANDLE hToken,
+  #   _In_  HANDLE hProfile
+  # );
+  ffi_lib :userenv
+  attach_function_private :UnloadUserProfile,
+    [:handle, :handle], :win32_bool
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa376389(v=vs.85).aspx
+  # BOOL WINAPI CheckTokenMembership(
+  #   _In_opt_  HANDLE TokenHandle,
+  #   _In_      PSID SidToCheck,
+  #   _Out_     PBOOL IsMember
+  # );
+  ffi_lib :advapi32
+  attach_function_private :CheckTokenMembership,
+    [:handle, :pointer, :pbool], :win32_bool
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa379650(v=vs.85).aspx
+  WELL_KNOWN_SID_TYPE = enum(
+    :WinNullSid                                   , 0,
+    :WinWorldSid                                  , 1,
+    :WinLocalSid                                  , 2,
+    :WinCreatorOwnerSid                           , 3,
+    :WinCreatorGroupSid                           , 4,
+    :WinCreatorOwnerServerSid                     , 5,
+    :WinCreatorGroupServerSid                     , 6,
+    :WinNtAuthoritySid                            , 7,
+    :WinDialupSid                                 , 8,
+    :WinNetworkSid                                , 9,
+    :WinBatchSid                                  , 10,
+    :WinInteractiveSid                            , 11,
+    :WinServiceSid                                , 12,
+    :WinAnonymousSid                              , 13,
+    :WinProxySid                                  , 14,
+    :WinEnterpriseControllersSid                  , 15,
+    :WinSelfSid                                   , 16,
+    :WinAuthenticatedUserSid                      , 17,
+    :WinRestrictedCodeSid                         , 18,
+    :WinTerminalServerSid                         , 19,
+    :WinRemoteLogonIdSid                          , 20,
+    :WinLogonIdsSid                               , 21,
+    :WinLocalSystemSid                            , 22,
+    :WinLocalServiceSid                           , 23,
+    :WinNetworkServiceSid                         , 24,
+    :WinBuiltinDomainSid                          , 25,
+    :WinBuiltinAdministratorsSid                  , 26,
+    :WinBuiltinUsersSid                           , 27,
+    :WinBuiltinGuestsSid                          , 28,
+    :WinBuiltinPowerUsersSid                      , 29,
+    :WinBuiltinAccountOperatorsSid                , 30,
+    :WinBuiltinSystemOperatorsSid                 , 31,
+    :WinBuiltinPrintOperatorsSid                  , 32,
+    :WinBuiltinBackupOperatorsSid                 , 33,
+    :WinBuiltinReplicatorSid                      , 34,
+    :WinBuiltinPreWindows2000CompatibleAccessSid  , 35,
+    :WinBuiltinRemoteDesktopUsersSid              , 36,
+    :WinBuiltinNetworkConfigurationOperatorsSid   , 37,
+    :WinAccountAdministratorSid                   , 38,
+    :WinAccountGuestSid                           , 39,
+    :WinAccountKrbtgtSid                          , 40,
+    :WinAccountDomainAdminsSid                    , 41,
+    :WinAccountDomainUsersSid                     , 42,
+    :WinAccountDomainGuestsSid                    , 43,
+    :WinAccountComputersSid                       , 44,
+    :WinAccountControllersSid                     , 45,
+    :WinAccountCertAdminsSid                      , 46,
+    :WinAccountSchemaAdminsSid                    , 47,
+    :WinAccountEnterpriseAdminsSid                , 48,
+    :WinAccountPolicyAdminsSid                    , 49,
+    :WinAccountRasAndIasServersSid                , 50,
+    :WinNTLMAuthenticationSid                     , 51,
+    :WinDigestAuthenticationSid                   , 52,
+    :WinSChannelAuthenticationSid                 , 53,
+    :WinThisOrganizationSid                       , 54,
+    :WinOtherOrganizationSid                      , 55,
+    :WinBuiltinIncomingForestTrustBuildersSid     , 56,
+    :WinBuiltinPerfMonitoringUsersSid             , 57,
+    :WinBuiltinPerfLoggingUsersSid                , 58,
+    :WinBuiltinAuthorizationAccessSid             , 59,
+    :WinBuiltinTerminalServerLicenseServersSid    , 60,
+    :WinBuiltinDCOMUsersSid                       , 61,
+    :WinBuiltinIUsersSid                          , 62,
+    :WinIUserSid                                  , 63,
+    :WinBuiltinCryptoOperatorsSid                 , 64,
+    :WinUntrustedLabelSid                         , 65,
+    :WinLowLabelSid                               , 66,
+    :WinMediumLabelSid                            , 67,
+    :WinHighLabelSid                              , 68,
+    :WinSystemLabelSid                            , 69,
+    :WinWriteRestrictedCodeSid                    , 70,
+    :WinCreatorOwnerRightsSid                     , 71,
+    :WinCacheablePrincipalsGroupSid               , 72,
+    :WinNonCacheablePrincipalsGroupSid            , 73,
+    :WinEnterpriseReadonlyControllersSid          , 74,
+    :WinAccountReadonlyControllersSid             , 75,
+    :WinBuiltinEventLogReadersGroup               , 76,
+    :WinNewEnterpriseReadonlyControllersSid       , 77,
+    :WinBuiltinCertSvcDComAccessGroup             , 78,
+    :WinMediumPlusLabelSid                        , 79,
+    :WinLocalLogonSid                             , 80,
+    :WinConsoleLogonSid                           , 81,
+    :WinThisOrganizationCertificateSid            , 82,
+    :WinApplicationPackageAuthoritySid            , 83,
+    :WinBuiltinAnyPackageSid                      , 84,
+    :WinCapabilityInternetClientSid               , 85,
+    :WinCapabilityInternetClientServerSid         , 86,
+    :WinCapabilityPrivateNetworkClientServerSid   , 87,
+    :WinCapabilityPicturesLibrarySid              , 88,
+    :WinCapabilityVideosLibrarySid                , 89,
+    :WinCapabilityMusicLibrarySid                 , 90,
+    :WinCapabilityDocumentsLibrarySid             , 91,
+    :WinCapabilitySharedUserCertificatesSid       , 92,
+    :WinCapabilityEnterpriseAuthenticationSid     , 93,
+    :WinCapabilityRemovableStorageSid             , 94
+  )
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa446585(v=vs.85).aspx
+  # BOOL WINAPI CreateWellKnownSid(
+  #   _In_       WELL_KNOWN_SID_TYPE WellKnownSidType,
+  #   _In_opt_   PSID DomainSid,
+  #   _Out_opt_  PSID pSid,
+  #   _Inout_    DWORD *cbSid
+  # );
+  ffi_lib :advapi32
+  attach_function_private :CreateWellKnownSid,
+    [WELL_KNOWN_SID_TYPE, :pointer, :pointer, :lpdword], :win32_bool
+
+  # http://msdn.microsoft.com/en-us/library/windows/desktop/aa379151(v=vs.85).aspx
+  # BOOL WINAPI IsValidSid(
+  #   _In_  PSID pSid
+  # );
+  ffi_lib :advapi32
+  attach_function_private :IsValidSid,
+    [:pointer], :win32_bool
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/yaml.rb

@@ -0,0 +1,24 @@
+require 'yaml'
+
+module Puppet::Util::Yaml
+  if defined?(::Psych::SyntaxError)
+    YamlLoadExceptions = [::StandardError, ::Psych::SyntaxError]
+  else
+    YamlLoadExceptions = [::StandardError]
+  end
+
+  class YamlLoadError < Puppet::Error; end
+
+  def self.load_file(filename, default_value = false)
+    yaml = YAML.load_file(filename)
+    yaml || default_value
+  rescue *YamlLoadExceptions => detail
+    raise YamlLoadError.new(detail.message, detail)
+  end
+
+  def self.dump(structure, filename)
+    Puppet::Util.replace_file(filename, 0660) do |fh|
+      YAML.dump(structure, fh)
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/util/zaml.rb

@@ -0,0 +1,419 @@
+# encoding: UTF-8
+#
+# The above encoding line is a magic comment to set the default source encoding
+# of this file for the Ruby interpreter.  It must be on the first or second
+# line of the file if an interpreter is in use.  In Ruby 1.9 and later, the
+# source encoding determines the encoding of String and Regexp objects created
+# from this source file.  This explicit encoding is important becuase otherwise
+# Ruby will pick an encoding based on LANG or LC_CTYPE environment variables.
+# These may be different from site to site so it's important for us to
+# establish a consistent behavior.  For more information on M17n please see:
+# http://links.puppetlabs.com/understanding_m17n
+
+# ZAML -- A partial replacement for YAML, writen with speed and code clarity
+#         in mind.  ZAML fixes one YAML bug (loading Exceptions) and provides
+#         a replacement for YAML.dump unimaginatively called ZAML.dump,
+#         which is faster on all known cases and an order of magnitude faster
+#         with complex structures.
+#
+# http://github.com/hallettj/zaml
+#
+# ## License (from upstream)
+#
+# Copyright (c) 2008-2009 ZAML contributers
+#
+# This program is dual-licensed under the GNU General Public License
+# version 3 or later and under the Apache License, version 2.0.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation, either version 3 of the License, or (at your
+# option) any later version; or under the terms of the Apache License,
+# Version 2.0.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License and the Apache License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see
+# <http://www.gnu.org/licenses/>.
+#
+# You may obtain a copy of the Apache License at
+# <https://www.apache.org/licenses/LICENSE-2.0.html>.
+
+require 'yaml'
+
+class ZAML
+  VERSION = "0.1.3"
+  #
+  # Class Methods
+  #
+  def self.dump(stuff, where='')
+    z = new
+    stuff.to_zaml(z)
+    where << z.to_s
+  end
+
+  #
+  # Instance Methods
+  #
+  def initialize
+    @result = []
+    @indent = nil
+    @structured_key_prefix = nil
+    @previously_emitted_object = {}
+    @next_free_label_number = 0
+    emit('--- ')
+  end
+
+  def nested(tail='  ')
+    old_indent = @indent
+    @indent = "#{@indent || "\n"}#{tail}"
+    yield
+    @indent = old_indent
+  end
+
+  class Label
+    #
+    # YAML only wants objects in the datastream once; if the same object
+    #    occurs more than once, we need to emit a label ("&idxxx") on the
+    #    first occurrence and then emit a back reference (*idxxx") on any
+    #    subsequent occurrence(s).
+    #
+    # To accomplish this we keeps a hash (by object id) of the labels of
+    #    the things we serialize as we begin to serialize them.  The labels
+    #    initially serialize as an empty string (since most objects are only
+    #    going to be be encountered once), but can be changed to a valid
+    #    (by assigning it a number) the first time it is subsequently used,
+    #    if it ever is.  Note that we need to do the label setup BEFORE we
+    #    start to serialize the object so that circular structures (in
+    #    which we will encounter a reference to the object as we serialize
+    #    it can be handled).
+    #
+    attr_accessor :this_label_number
+
+    def initialize(obj,indent)
+      @indent = indent
+      @this_label_number = nil
+      @obj = obj # prevent garbage collection so that object id isn't reused
+    end
+
+    def to_s
+      @this_label_number ? ('&id%03d%s' % [@this_label_number, @indent]) : ''
+    end
+
+    def reference
+      @reference         ||= '*id%03d' % @this_label_number
+    end
+  end
+
+  def label_for(obj)
+    @previously_emitted_object[obj.object_id]
+  end
+
+  def new_label_for(obj)
+    label = Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"}  " : ' ')
+    @previously_emitted_object[obj.object_id] = label
+    label
+  end
+
+  def first_time_only(obj)
+    if label = label_for(obj)
+      label.this_label_number ||= (@next_free_label_number += 1)
+      emit(label.reference)
+    else
+      with_structured_prefix(obj) do
+        emit(new_label_for(obj))
+        yield
+      end
+    end
+  end
+
+  def with_structured_prefix(obj)
+    if @structured_key_prefix
+      unless obj.is_a?(String) and obj !~ /\n/
+        emit(@structured_key_prefix)
+        @structured_key_prefix = nil
+      end
+    end
+    yield
+  end
+
+  def emit(s)
+    @result << s
+    @recent_nl = false unless s.kind_of?(Label)
+  end
+
+  def nl(s = nil)
+    emit(@indent || "\n") unless @recent_nl
+    emit(s) if s
+    @recent_nl = true
+  end
+
+  def to_s
+    @result.join
+  end
+
+  def prefix_structured_keys(x)
+    @structured_key_prefix = x
+    yield
+    nl unless @structured_key_prefix
+    @structured_key_prefix = nil
+  end
+end
+
+################################################################
+#
+#   Behavior for custom classes
+#
+################################################################
+
+class Object
+  # Users of this method need to do set math consistently with the
+  # result. Since #instance_variables returns strings in 1.8 and symbols
+  # on 1.9, standardize on symbols
+  if RUBY_VERSION[0,3] == '1.8'
+    def to_yaml_properties
+      instance_variables.map(&:to_sym)
+    end
+  else
+    def to_yaml_properties
+      instance_variables
+    end
+  end
+
+  def yaml_property_munge(x)
+    x
+  end
+
+  def zamlized_class_name(root)
+    cls = self.class
+    "!ruby/#{root.name.downcase}#{cls == root ? '' : ":#{cls.respond_to?(:name) ? cls.name : cls}"}"
+  end
+
+  def to_zaml(z)
+    z.first_time_only(self) {
+      z.emit(zamlized_class_name(Object))
+      z.nested {
+        instance_variables = to_yaml_properties
+        if instance_variables.empty?
+          z.emit(" {}")
+        else
+          instance_variables.each { |v|
+            z.nl
+            v.to_s[1..-1].to_zaml(z)       # Remove leading '@'
+            z.emit(': ')
+            yaml_property_munge(instance_variable_get(v)).to_zaml(z)
+          }
+        end
+      }
+    }
+  end
+end
+
+################################################################
+#
+#   Behavior for built-in classes
+#
+################################################################
+
+class NilClass
+  def to_zaml(z)
+    z.emit('')        # NOTE: blank turns into nil in YAML.load
+  end
+end
+
+class Symbol
+  def to_zaml(z)
+    z.emit("!ruby/sym ")
+    to_s.to_zaml(z)
+  end
+end
+
+class TrueClass
+  def to_zaml(z)
+    z.emit('true')
+  end
+end
+
+class FalseClass
+  def to_zaml(z)
+    z.emit('false')
+  end
+end
+
+class Numeric
+  def to_zaml(z)
+    z.emit(self)
+  end
+end
+
+class Regexp
+  def to_zaml(z)
+    z.first_time_only(self) { z.emit("#{zamlized_class_name(Regexp)} #{inspect}") }
+  end
+end
+
+class Exception
+  def to_zaml(z)
+    z.emit(zamlized_class_name(Exception))
+    z.nested {
+      z.nl("message: ")
+      message.to_zaml(z)
+    }
+  end
+  #
+  # Monkey patch for buggy Exception restore in YAML
+  #
+  #     This makes it work for now but is not very future-proof; if things
+  #     change we'll most likely want to remove this.  To mitigate the risks
+  #     as much as possible, we test for the bug before appling the patch.
+  #
+  if respond_to? :yaml_new and yaml_new(self, :tag, "message" => "blurp").message != "blurp"
+    def self.yaml_new( klass, tag, val )
+      o = YAML.object_maker( klass, {} ).exception(val.delete( 'message'))
+      val.each_pair do |k,v|
+        o.instance_variable_set("@#{k}", v)
+      end
+      o
+    end
+  end
+end
+
+class String
+  ZAML_ESCAPES = {
+    "\a" => "\\a", "\e" => "\\e", "\f" => "\\f", "\n" => "\\n",
+    "\r" => "\\r", "\t" => "\\t", "\v" => "\\v"
+  }
+
+  def to_zaml(z)
+    z.with_structured_prefix(self) do
+      case
+      when self == ''
+        z.emit('""')
+      when self.to_ascii8bit !~ /\A(?: # ?: non-capturing group (grouping with no back references)
+                 [\x09\x0A\x0D\x20-\x7E]            # ASCII
+               | [\xC2-\xDF][\x80-\xBF]             # non-overlong 2-byte
+               |  \xE0[\xA0-\xBF][\x80-\xBF]        # excluding overlongs
+               | [\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}  # straight 3-byte
+               |  \xED[\x80-\x9F][\x80-\xBF]        # excluding surrogates
+               |  \xF0[\x90-\xBF][\x80-\xBF]{2}     # planes 1-3
+               | [\xF1-\xF3][\x80-\xBF]{3}          # planes 4-15
+               |  \xF4[\x80-\x8F][\x80-\xBF]{2}     # plane 16
+               )*\z/mnx
+        # Emit the binary tag, then recurse. Ruby splits BASE64 output at the 60
+        # character mark when packing strings, and we can wind up a multi-line
+        # string here.  We could reimplement the multi-line string logic,
+        # but why would we - this does just as well for producing solid output.
+        z.emit("!binary ")
+        [self].pack("m*").to_zaml(z)
+
+      # Only legal UTF-8 characters can make it this far, so we are safe
+      # against emitting something dubious. That means we don't need to mess
+      # about, just emit them directly. --daniel 2012-07-14
+      when ((self =~ /\A[a-zA-Z\/][-\[\]_\/.a-zA-Z0-9]*\z/) and
+          (self !~ /^(?:true|false|yes|no|on|null|off)$/i))
+        # simple string literal, safe to emit unquoted.
+        z.emit(self)
+      when (self =~ /\n/ and self !~ /\A\s/ and self !~ /\s\z/)
+        # embedded newline, split line-wise in quoted string block form.
+        if self[-1..-1] == "\n" then z.emit('|+') else z.emit('|-') end
+        z.nested { split("\n",-1).each { |line| z.nl; z.emit(line) } }
+      else
+        # ...though we still have to escape unsafe characters.
+        escaped = gsub(/[\\"\x00-\x1F]/) do |c|
+          ZAML_ESCAPES[c] || "\\x#{c[0].ord.to_s(16)}"
+        end
+        z.emit("\"#{escaped}\"")
+      end
+    end
+  end
+
+  # Return a guranteed ASCII-8BIT encoding for Ruby 1.9 This is a helper
+  # method for other methods that perform regular expressions against byte
+  # sequences deliberately rather than dealing with characters.
+  # The method may or may not return a new instance.
+  if String.method_defined?(:encoding)
+    ASCII_ENCODING = Encoding.find("ASCII-8BIT")
+    def to_ascii8bit
+      if self.encoding == ASCII_ENCODING
+        self
+      else
+        self.dup.force_encoding(ASCII_ENCODING)
+      end
+    end
+  else
+    def to_ascii8bit
+      self
+    end
+  end
+end
+
+class Hash
+  def to_zaml(z)
+    z.first_time_only(self) {
+      z.nested {
+        if empty?
+          z.emit('{}')
+        else
+          each_pair { |k, v|
+            z.nl
+            z.prefix_structured_keys('? ') { k.to_zaml(z) }
+            z.emit(': ')
+            v.to_zaml(z)
+          }
+        end
+      }
+    }
+  end
+end
+
+class Array
+  def to_zaml(z)
+    z.first_time_only(self) {
+      z.nested {
+        if empty?
+          z.emit('[]')
+        else
+          each { |v| z.nl('- '); v.to_zaml(z) }
+        end
+      }
+    }
+  end
+end
+
+class Time
+  def to_zaml(z)
+    # 2008-12-06 10:06:51.373758 -07:00
+    ms = ("%0.6f" % (usec * 1e-6))[2..-1]
+    offset = "%+0.2i:%0.2i" % [utc_offset / 3600.0, (utc_offset / 60) % 60]
+    z.emit(self.strftime("%Y-%m-%d %H:%M:%S.#{ms} #{offset}"))
+  end
+end
+
+class Date
+  def to_zaml(z)
+    z.emit(strftime('%Y-%m-%d'))
+  end
+end
+
+class Range
+  def to_zaml(z)
+    z.first_time_only(self) {
+      z.emit(zamlized_class_name(Range))
+      z.nested {
+        z.nl
+        z.emit('begin: ')
+        z.emit(first)
+        z.nl
+        z.emit('end: ')
+        z.emit(last)
+        z.nl
+        z.emit('excl: ')
+        z.emit(exclude_end?)
+      }
+    }
+  end
+end