puppet 3.8.7 → 4.0.0

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

@@ -1,179 +0,0 @@
-SafeYAML
-========
-
-[![Build Status](https://travis-ci.org/dtao/safe_yaml.png)](http://travis-ci.org/dtao/safe_yaml)
-
-The **SafeYAML** gem provides an alternative implementation of `YAML.load` suitable for accepting user input in Ruby applications. Unlike Ruby's built-in implementation of `YAML.load`, SafeYAML's version will not expose apps to arbitrary code execution exploits (such as [the ones discovered](http://www.reddit.com/r/netsec/comments/167c11/serious_vulnerability_in_ruby_on_rails_allowing/) [in Rails in early 2013](http://www.h-online.com/open/news/item/Rails-developers-close-another-extremely-critical-flaw-1793511.html)).
-
-**If you encounter any issues with SafeYAML, check out the 'Common Issues' section below.** If you don't see anything that addresses the problem you're experiencing, by all means, [create an issue](https://github.com/dtao/safe_yaml/issues/new)!
-
-Installation
-------------
-
-Add this line to your application's Gemfile:
-
-    gem "safe_yaml"
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install safe_yaml
-
-Configuration
--------------
-
-Configuring SafeYAML should be quick. In most cases, you will probably only have to think about two things:
-
-1. What do you want the `YAML` module's *default* behavior to be? Set the `SafeYAML::OPTIONS[:default_mode]` option to either `:safe` or `:unsafe` to control this. If you do neither, SafeYAML will default to `:safe` mode but will issue a warning the first time you call `YAML.load`.
-2. Do you want to allow symbols by default? Set the `SafeYAML::OPTIONS[:deserialize_symbols]` option to `true` or `false` to control this. The default is `false`, which means that SafeYAML will deserialize symbols in YAML documents as strings.
-
-For more information on these and other options, see the "Usage" section down below.
-
-Explanation
------------
-
-Suppose your application were to use a popular open source library which contained code like this:
-
-```ruby
-class ClassBuilder
-  def []=(key, value)
-    @class ||= Class.new
-
-    @class.class_eval <<-EOS
-      def #{key}
-        #{value}
-      end
-    EOS
-  end
-
-  def create
-    @class.new
-  end
-end
-```
-
-Now, if you were to use `YAML.load` on user input anywhere in your application without the SafeYAML gem installed, an attacker who suspected you were using this library could send a request with a carefully-crafted YAML string to execute arbitrary code (yes, including `system("unix command")`) on your servers.
-
-This simple example demonstrates the vulnerability:
-
-```ruby
-yaml = <<-EOYAML
---- !ruby/hash:ClassBuilder
-"foo; end; puts %(I'm in yr system!); def bar": "baz"
-EOYAML
-```
-
-    > YAML.load(yaml)
-    I'm in yr system!
-    => #<ClassBuilder:0x007fdbbe2e25d8 @class=#<Class:0x007fdbbe2e2510>>
-
-With SafeYAML, the same attacker would be thwarted:
-
-    > require "safe_yaml"
-    => true
-    > YAML.load(yaml, :safe => true)
-    => {"foo; end; puts %(I'm in yr system!); def bar"=>"baz"}
-
-Usage
------
-
-When you require the safe_yaml gem in your project, `YAML.load` is patched to accept one additional (optional) `options` parameter. This changes the method signature as follows:
-
-- for Syck and Psych prior to Ruby 1.9.3: `YAML.load(yaml, options={})`
-- for Psych in 1.9.3 and later: `YAML.load(yaml, filename=nil, options={})`
-
-The most important option is the `:safe` option (default: `true`), which controls whether or not to deserialize arbitrary objects when parsing a YAML document. The other options, along with explanations, are as follows.
-
-- `:deserialize_symbols` (default: `false`): Controls whether or not YAML will deserialize symbols. It is probably best to only enable this option where necessary, e.g. to make trusted libraries work. Symbols receive special treatment in Ruby and are not garbage collected, which means deserializing them indiscriminately may render your site vulnerable to a DOS attack (hence `false` as a default value).
-
-- `:whitelisted_tags`: Accepts an array of YAML tags that designate trusted types, e.g., ones that can be deserialized without worrying about any resulting security vulnerabilities. When any of the given tags are encountered in a YAML document, the associated data will be parsed by the underlying YAML engine (Syck or Psych) for the version of Ruby you are using. See the "Whitelisting Trusted Types" section below for more information.
-
-- `:custom_initializers`: Similar to the `:whitelisted_tags` option, but allows you to provide your own initializers for specified tags rather than using Syck or Psyck. Accepts a hash with string tags for keys and lambdas for values.
-
-- `:raise_on_unknown_tag` (default: `false`): Represents the highest possible level of paranoia (not necessarily a bad thing); if the YAML engine encounters any tag other than ones that are automatically trusted by SafeYAML or that you've explicitly whitelisted, it will raise an exception. This may be a good choice if you expect to always be dealing with perfectly safe YAML and want your application to fail loudly upon encountering questionable data.
-
-All of the above options can be set at the global level via `SafeYAML::OPTIONS`. You can also set each one individually per call to `YAML.load`; an option explicitly passed to `load` will take precedence over an option specified globally.
-
-Supported Types
----------------
-
-The way that SafeYAML works is by restricting the kinds of objects that can be deserialized via `YAML.load`. More specifically, only the following types of objects can be deserialized by default:
-
-- Hashes
-- Arrays
-- Strings
-- Numbers
-- Dates
-- Times
-- Booleans
-- Nils
-
-Again, deserialization of symbols can be enabled globally by setting `SafeYAML::OPTIONS[:deserialize_symbols] = true`, or in a specific call to `YAML.load([some yaml], :deserialize_symbols => true)`.
-
-Whitelisting Trusted Types
---------------------------
-
-SafeYAML supports whitelisting certain YAML tags for trusted types. This is handy when your application uses YAML to serialize and deserialize certain types not listed above, which you know to be free of any deserialization-related vulnerabilities.
-
-The easiest way to whitelist types is by calling `SafeYAML.whitelist!`, which can accept a variable number of safe types, e.g.:
-
-```ruby
-SafeYAML.whitelist!(FrobDispenser, GobbleFactory)
-```
-
-You can also whitelist YAML *tags* via the `:whitelisted_tags` option:
-
-```ruby
-# Using Syck
-SafeYAML::OPTIONS[:whitelisted_tags] = ["tag:ruby.yaml.org,2002:object:OpenStruct"]
-
-# Using Psych
-SafeYAML::OPTIONS[:whitelisted_tags] = ["!ruby/object:OpenStruct"]
-```
-
-And in case you were wondering: no, this feature will *not* allow would-be attackers to embed untrusted types within trusted types:
-
-```ruby
-yaml = <<-EOYAML
---- !ruby/object:OpenStruct 
-table: 
-  :backdoor: !ruby/hash:ClassBuilder 
-    "foo; end; puts %(I'm in yr system!); def bar": "baz"
-EOYAML
-```
-
-    > YAML.safe_load(yaml)
-    => #<OpenStruct :backdoor={"foo; end; puts %(I'm in yr system!); def bar"=>"baz"}>
-
-Known Issues
-------------
-
-If you add SafeYAML to your project and start seeing any errors about missing keys, or you notice mysterious strings that look like `":foo"` (i.e., start with a colon), it's likely you're seeing errors from symbols being saved in YAML format. If you are able to modify the offending code, you might want to consider changing your YAML content to use plain vanilla strings instead of symbols. If not, you may need to set the `:deserialize_symbols` option to `true`, either in calls to `YAML.load` or--as a last resort--globally, with `SafeYAML::OPTIONS[:deserialize_symbols]`.
-
-Also be aware that some Ruby libraries, particularly those requiring inter-process communication, leverage YAML's object deserialization functionality and therefore may break or otherwise be impacted by SafeYAML. The following list includes known instances of SafeYAML's interaction with other Ruby gems:
-
-- [**ActiveRecord**](https://github.com/rails/rails/tree/master/activerecord): uses YAML to control serialization of model objects using the `serialize` class method. If you find that accessing serialized properties on your ActiveRecord models is causing errors, chances are you may need to:
-  1. set the `:deserialize_symbols` option to `true`,
-  2. whitelist some of the types in your serialized data via `SafeYAML.whitelist!` or the `:whitelisted_tags` option, or
-  3. both
-- [**Guard**](https://github.com/guard/guard): Uses YAML as a serialization format for notifications. The data serialized uses symbolic keys, so setting `SafeYAML::OPTIONS[:deserialize_symbols] = true` is necessary to allow Guard to work.
-- [**sidekiq**](https://github.com/mperham/sidekiq): Uses a YAML configiuration file with symbolic keys, so setting `SafeYAML::OPTIONS[:deserialize_symbols] = true` should allow it to work.
-
-The above list will grow over time, as more issues are discovered.
-
-Caveat
-------
-
-My intention is to eventually adopt [semantic versioning](http://semver.org/) with this gem, if it ever gets to version 1.0 (i.e., doesn't become obsolete by then). Since it isn't there yet, that means that API may well change from one version to the next. Please keep that in mind if you are using it in your application.
-
-To be clear: my *goal* is for SafeYAML to make it as easy as possible to protect existing applications from object deserialization exploits. Any and all feedback is more than welcome!
-
-Requirements
-------------
-
-SafeYAML requires Ruby 1.8.7 or newer and works with both [Syck](http://www.ruby-doc.org/stdlib-1.8.7/libdoc/yaml/rdoc/YAML.html) and [Psych](http://github.com/tenderlove/psych).
-
-If you are using a version of Ruby where Psych is the default YAML engine (e.g., 1.9.3) but you want to use Syck, be sure to set `YAML::ENGINE.yamler = "syck"` **before** requiring the safe_yaml gem.

data/lib/puppet/vendor/safe_yaml/Rakefile

@@ -1,6 +0,0 @@
-require "rspec/core/rake_task"
-
-desc "Run specs"
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = %w(--color)
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/deep.rb

@@ -1,34 +0,0 @@
-module SafeYAML
-  class Deep
-    def self.freeze(object)
-      object.each do |*entry|
-        value = entry.last
-        case value
-        when String, Regexp
-          value.freeze
-        when Enumerable
-          Deep.freeze(value)
-        end
-      end
-
-      return object.freeze
-    end
-
-    def self.copy(object)
-      duplicate = object.dup rescue object
-
-      case object
-      when Array
-        (0...duplicate.count).each do |i|
-          duplicate[i] = Deep.copy(duplicate[i])
-        end
-      when Hash
-        duplicate.keys.each do |key|
-          duplicate[key] = Deep.copy(duplicate[key])
-        end
-      end
-
-      duplicate
-    end
-  end
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/parse/date.rb

@@ -1,27 +0,0 @@
-module SafeYAML
-  class Parse
-    class Date
-      # This one's easy enough :)
-      DATE_MATCHER = /\A(\d{4})-(\d{2})-(\d{2})\Z/.freeze
-
-      # This unbelievable little gem is taken basically straight from the YAML spec, but made
-      # slightly more readable (to my poor eyes at least) to me:
-      # http://yaml.org/type/timestamp.html
-      TIME_MATCHER = /\A\d{4}-\d{1,2}-\d{1,2}(?:[Tt]|\s+)\d{1,2}:\d{2}:\d{2}(?:\.\d*)?\s*(?:Z|[-+]\d{1,2}(?::?\d{2})?)?\Z/.freeze
-
-      SECONDS_PER_DAY = 60 * 60 * 24
-      MICROSECONDS_PER_SECOND = 1000000
-
-      # So this is weird. In Ruby 1.8.7, the DateTime#sec_fraction method returned fractional
-      # seconds in units of DAYS for some reason. In 1.9.2, they changed the units -- much more
-      # reasonably -- to seconds.
-      SEC_FRACTION_MULTIPLIER = RUBY_VERSION == "1.8.7" ? (SECONDS_PER_DAY * MICROSECONDS_PER_SECOND) : MICROSECONDS_PER_SECOND
-
-      def self.value(value)
-        d = DateTime.parse(value)
-        usec = d.sec_fraction * SEC_FRACTION_MULTIPLIER
-        Time.utc(d.year, d.month, d.day, d.hour, d.min, d.sec, usec) - (d.offset * SECONDS_PER_DAY)
-      end
-    end
-  end
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/parse/hexadecimal.rb

@@ -1,12 +0,0 @@
-module SafeYAML
-  class Parse
-    class Hexadecimal
-      MATCHER = /\A[-+]?0x[0-9a-fA-F_]+\Z/.freeze
-
-      def self.value(value)
-        # This is safe to do since we already validated the value.
-        return Integer(value.gsub(/_/, ""))
-      end
-    end
-  end
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/parse/sexagesimal.rb

@@ -1,26 +0,0 @@
-module SafeYAML
-  class Parse
-    class Sexagesimal
-      INTEGER_MATCHER = /\A[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\Z/.freeze
-      FLOAT_MATCHER = /\A[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\.[0-9_]*\Z/.freeze
-
-      def self.value(value)
-        before_decimal, after_decimal = value.split(".")
-
-        whole_part = 0
-        multiplier = 1
-
-        before_decimal = before_decimal.split(":")
-        until before_decimal.empty?
-          whole_part += (Float(before_decimal.pop) * multiplier)
-          multiplier *= 60
-        end
-
-        result = whole_part
-        result += Float("." + after_decimal) unless after_decimal.nil?
-        result *= -1 if value[0] == "-"
-        result
-      end
-    end
-  end
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/psych_handler.rb

@@ -1,92 +0,0 @@
-require "psych"
-require "base64"
-
-module SafeYAML
-  class PsychHandler < Psych::Handler
-    def initialize(options)
-      @options      = SafeYAML::OPTIONS.merge(options || {})
-      @initializers = @options[:custom_initializers] || {}
-      @anchors      = {}
-      @stack        = []
-      @current_key  = nil
-      @result       = nil
-    end
-
-    def result
-      @result
-    end
-
-    def add_to_current_structure(value, anchor=nil, quoted=nil, tag=nil)
-      value = Transform.to_proper_type(value, quoted, tag, @options)
-
-      @anchors[anchor] = value if anchor
-
-      if @result.nil?
-        @result = value
-        @current_structure = @result
-        return
-      end
-
-      if @current_structure.respond_to?(:<<)
-        @current_structure << value
-
-      elsif @current_structure.respond_to?(:[]=)
-        if @current_key.nil?
-          @current_key = value
-
-        else
-          if @current_key == "<<"
-            @current_structure.merge!(value)
-          else
-            @current_structure[@current_key] = value
-          end
-
-          @current_key = nil
-        end
-
-      else
-        raise "Don't know how to add to a #{@current_structure.class}!"
-      end
-    end
-
-    def end_current_structure
-      @stack.pop
-      @current_structure = @stack.last
-    end
-
-    def streaming?
-      false
-    end
-
-    # event handlers
-    def alias(anchor)
-      add_to_current_structure(@anchors[anchor])
-    end
-
-    def scalar(value, anchor, tag, plain, quoted, style)
-      add_to_current_structure(value, anchor, quoted, tag)
-    end
-
-    def start_mapping(anchor, tag, implicit, style)
-      map = @initializers.include?(tag) ? @initializers[tag].call : {}
-      self.add_to_current_structure(map, anchor)
-      @current_structure = map
-      @stack.push(map)
-    end
-
-    def end_mapping
-      self.end_current_structure()
-    end
-
-    def start_sequence(anchor, tag, implicit, style)
-      seq = @initializers.include?(tag) ? @initializers[tag].call : []
-      self.add_to_current_structure(seq, anchor)
-      @current_structure = seq
-      @stack.push(seq)
-    end
-
-    def end_sequence
-      self.end_current_structure()
-    end
-  end
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/psych_resolver.rb

@@ -1,52 +0,0 @@
-module SafeYAML
-  class PsychResolver < Resolver
-    NODE_TYPES = {
-      Psych::Nodes::Document => :root,
-      Psych::Nodes::Mapping  => :map,
-      Psych::Nodes::Sequence => :seq,
-      Psych::Nodes::Scalar   => :scalar,
-      Psych::Nodes::Alias    => :alias
-    }.freeze
-
-    def initialize(options={})
-      super
-      @aliased_nodes = {}
-    end
-
-    def resolve_root(root)
-      resolve_seq(root).first
-    end
-
-    def resolve_alias(node)
-      resolve_node(@aliased_nodes[node.anchor])
-    end
-
-    def native_resolve(node)
-      @visitor ||= SafeYAML::SafeToRubyVisitor.new(self)
-      @visitor.accept(node)
-    end
-
-    def get_node_type(node)
-      NODE_TYPES[node.class]
-    end
-
-    def get_node_tag(node)
-      node.tag
-    end
-
-    def get_node_value(node)
-      @aliased_nodes[node.anchor] = node if node.respond_to?(:anchor) && node.anchor
-
-      case get_node_type(node)
-      when :root, :map, :seq
-        node.children
-      when :scalar
-        node.value
-      end
-    end
-
-    def value_is_quoted?(node)
-      node.quoted
-    end
-  end
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/resolver.rb

@@ -1,94 +0,0 @@
-module SafeYAML
-  class Resolver
-    def initialize(options)
-      @options              = SafeYAML::OPTIONS.merge(options || {})
-      @whitelist            = @options[:whitelisted_tags] || []
-      @initializers         = @options[:custom_initializers] || {}
-      @raise_on_unknown_tag = @options[:raise_on_unknown_tag]
-    end
-
-    def resolve_node(node)
-      return node if !node
-      return self.native_resolve(node) if tag_is_whitelisted?(self.get_node_tag(node))
-
-      case self.get_node_type(node)
-      when :root
-        resolve_root(node)
-      when :map
-        resolve_map(node)
-      when :seq
-        resolve_seq(node)
-      when :scalar
-        resolve_scalar(node)
-      when :alias
-        resolve_alias(node)
-      else
-        raise "Don't know how to resolve this node: #{node.inspect}"
-      end
-    end
-
-    def resolve_map(node)
-      tag  = get_and_check_node_tag(node)
-      hash = @initializers.include?(tag) ? @initializers[tag].call : {}
-      map  = normalize_map(self.get_node_value(node))
-
-      # Take the "<<" key nodes first, as these are meant to approximate a form of inheritance.
-      inheritors = map.select { |key_node, value_node| resolve_node(key_node) == "<<" }
-      inheritors.each do |key_node, value_node|
-        merge_into_hash(hash, resolve_node(value_node))
-      end
-
-      # All that's left should be normal (non-"<<") nodes.
-      (map - inheritors).each do |key_node, value_node|
-        hash[resolve_node(key_node)] = resolve_node(value_node)
-      end
-
-      return hash
-    end
-
-    def resolve_seq(node)
-      seq = self.get_node_value(node)
-
-      tag = get_and_check_node_tag(node)
-      arr = @initializers.include?(tag) ? @initializers[tag].call : []
-
-      seq.inject(arr) { |array, node| array << resolve_node(node) }
-    end
-
-    def resolve_scalar(node)
-      Transform.to_proper_type(self.get_node_value(node), self.value_is_quoted?(node), get_and_check_node_tag(node), @options)
-    end
-
-    def get_and_check_node_tag(node)
-      tag = self.get_node_tag(node)
-      SafeYAML.tag_safety_check!(tag, @options)
-      tag
-    end
-
-    def tag_is_whitelisted?(tag)
-      @whitelist.include?(tag)
-    end
-
-    def options
-      @options
-    end
-
-    private
-    def normalize_map(map)
-      # Syck creates Hashes from maps.
-      if map.is_a?(Hash)
-        map.inject([]) { |arr, key_and_value| arr << key_and_value }
-
-      # Psych is really weird; it flattens out a Hash completely into: [key, value, key, value, ...]
-      else
-        map.each_slice(2).to_a
-      end
-    end
-
-    def merge_into_hash(hash, array)
-      array.each do |key, value|
-        hash[key] = value
-      end
-    end
-  end
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/safe_to_ruby_visitor.rb

@@ -1,17 +0,0 @@
-module SafeYAML
-  class SafeToRubyVisitor < Psych::Visitors::ToRuby
-    def initialize(resolver)
-      super()
-      @resolver = resolver
-    end
-
-    def accept(node)
-      if node.tag
-        SafeYAML.tag_safety_check!(node.tag, @resolver.options)
-        return super
-      end
-
-      @resolver.resolve_node(node)
-    end
-  end
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/syck_hack.rb

@@ -1,36 +0,0 @@
-# Hack to JRuby 1.8's YAML Parser Yecht
-#
-# This file is always loaded AFTER either syck or psych are already
-# loaded. It then looks at what constants are available and creates
-# a consistent view on all rubys.
-#
-# Taken from rubygems and modified.
-# See https://github.com/rubygems/rubygems/blob/master/lib/rubygems/syck_hack.rb
-
-module YAML
-  # In newer 1.9.2, there is a Syck toplevel constant instead of it
-  # being underneith YAML. If so, reference it back under YAML as
-  # well.
-  if defined? ::Syck
-    # for tests that change YAML::ENGINE
-    # 1.8 does not support the second argument to const_defined?
-    remove_const :Syck rescue nil
-
-    Syck = ::Syck
-
-  # JRuby's "Syck" is called "Yecht"
-  elsif defined? YAML::Yecht
-    Syck = YAML::Yecht
-  end
-end
-
-# Sometime in the 1.9 dev cycle, the Syck constant was moved from under YAML
-# to be a toplevel constant. So gemspecs created under these versions of Syck
-# will have references to Syck::DefaultKey.
-#
-# So we need to be sure that we reference Syck at the toplevel too so that
-# we can always load these kind of gemspecs.
-#
-if !defined?(Syck)
-  Syck = YAML::Syck
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/syck_node_monkeypatch.rb

@@ -1,43 +0,0 @@
-# This is, admittedly, pretty insane. Fundamentally the challenge here is this: if we want to allow
-# whitelisting of tags (while still leveraging Syck's internal functionality), then we have to
-# change how Syck::Node#transform works. But since we (SafeYAML) do not control instantiation of
-# Syck::Node objects, we cannot, for example, subclass Syck::Node and override #tranform the "easy"
-# way. So the only choice is to monkeypatch, like this. And the only way to make this work
-# recursively with potentially call-specific options (that my feeble brain can think of) is to set
-# pseudo-global options on the first call and unset them once the recursive stack has fully unwound.
-
-monkeypatch = <<-EORUBY
-  class Node
-    @@safe_transform_depth     = 0
-    @@safe_transform_whitelist = nil
-
-    def safe_transform(options={})
-      begin
-        @@safe_transform_depth += 1
-        @@safe_transform_whitelist ||= options[:whitelisted_tags]
-
-        if self.type_id
-          SafeYAML.tag_safety_check!(self.type_id, options)
-          return unsafe_transform if @@safe_transform_whitelist.include?(self.type_id)
-        end
-
-        SafeYAML::SyckResolver.new.resolve_node(self)
-
-      ensure
-        @@safe_transform_depth -= 1
-        if @@safe_transform_depth == 0
-          @@safe_transform_whitelist = nil
-        end
-      end
-    end
-
-    alias_method :unsafe_transform, :transform
-    alias_method :transform, :safe_transform
-  end
-EORUBY
-
-if defined?(YAML::Syck::Node)
-  YAML::Syck.module_eval monkeypatch
-else
-  Syck.module_eval monkeypatch
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/syck_resolver.rb

@@ -1,38 +0,0 @@
-module SafeYAML
-  class SyckResolver < Resolver
-    QUOTE_STYLES = [
-      :quote1,
-      :quote2
-    ].freeze
-
-    NODE_TYPES = {
-      Hash   => :map,
-      Array  => :seq,
-      String => :scalar
-    }.freeze
-
-    def initialize(options={})
-      super
-    end
-
-    def native_resolve(node)
-      node.transform(self.options)
-    end
-
-    def get_node_type(node)
-      NODE_TYPES[node.value.class]
-    end
-
-    def get_node_tag(node)
-      node.type_id
-    end
-
-    def get_node_value(node)
-      node.value
-    end
-
-    def value_is_quoted?(node)
-      QUOTE_STYLES.include?(node.instance_variable_get(:@style))
-    end
-  end
-end

data/lib/puppet/vendor/safe_yaml/lib/safe_yaml/transform/to_boolean.rb

@@ -1,21 +0,0 @@
-module SafeYAML
-  class Transform
-    class ToBoolean
-      include TransformationMap
-
-      set_predefined_values({
-        "yes"   => true,
-        "on"    => true,
-        "true"  => true,
-        "no"    => false,
-        "off"   => false,
-        "false" => false
-      })
-
-      def transform?(value)
-        return false if value.length > 5
-        return PREDEFINED_VALUES.include?(value), PREDEFINED_VALUES[value]
-      end
-    end
-  end
-end