puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/regsubst.rb

@@ -1,80 +0,0 @@
-# Perform regexp replacement on a string or array of strings.
-#
-# @example
-#
-# Get the third octet from the node's IP address:
-#
-#   $i3 = regsubst($ipaddress,'^(\\d+)\\.(\\d+)\\.(\\d+)\\.(\\d+)$','\\3')
-#
-# Put angle brackets around each octet in the node's IP address:
-#
-#   $x = regsubst($ipaddress, /([0-9]+)/, '<\\1>', 'G')
-#
-# @param target [Array[String]|String]
-#      The string or array of strings to operate on.  If an array, the replacement will be
-#      performed on each of the elements in the array, and the return value will be an array.
-# @param regexp [String|Regexp|Type[Regexp]]
-#      The regular expression matching the target string.  If you want it anchored at the start
-#      and or end of the string, you must do that with ^ and $ yourself.
-# @param replacement [String|Hash[String, String]]
-#      Replacement string. Can contain backreferences to what was matched using \\0 (whole match),
-#      \\1 (first set of parentheses), and so on.
-#      If the second argument is a Hash, and the matched text is one of its keys, the corresponding value is the replacement string.
-# @param flags [String]
-#      Optional. String of single letter flags for how the regexp is interpreted (E, I, and M cannot be used
-#      if pattern is a precompiled regexp):
-#        - *E*         Extended regexps
-#        - *I*         Ignore case in regexps
-#        - *M*         Multiline regexps
-#        - *G*         Global replacement; all occurrences of the regexp in each target string will be replaced.  Without this, only the first occurrence will be replaced.
-# @param encoding [String]
-#      Optional. How to handle multibyte characters when compiling the regexp (must not be used when pattern is a
-#      precompiled regexp). A single-character string with the following values:
-#        - *N*         None
-#        - *E*         EUC
-#        - *S*         SJIS
-#        - *U*         UTF-8
-# @return [Array[String]|String] The result of the substitution. Result type is the same as for the target parameter.
-#
-Puppet::Functions.create_function(:regsubst) do
-  dispatch :regsubst_string do
-    param          'Variant[Array[String],String]',       :target
-    param          'String',                              :pattern
-    param          'Variant[String,Hash[String,String]]', :replacement
-    optional_param 'Optional[Pattern[/^[GEIM]*$/]]',      :flags
-    optional_param "Enum['N','E','S','U']",               :encoding
-  end
-
-  dispatch :regsubst_regexp do
-    param          'Variant[Array[String],String]',       :target
-    param          'Variant[Regexp,Type[Regexp]]',        :pattern
-    param          'Variant[String,Hash[String,String]]', :replacement
-    optional_param 'Pattern[/^G?$/]',                     :flags
-  end
-
-  def regsubst_string(target, pattern, replacement, flags = nil, encoding = nil)
-    re_flags = 0
-    operation = :sub
-    if !flags.nil?
-      flags.split(//).each do |f|
-        case f
-        when 'G' then operation = :gsub
-        when 'E' then re_flags |= Regexp::EXTENDED
-        when 'I' then re_flags |= Regexp::IGNORECASE
-        when 'M' then re_flags |= Regexp::MULTILINE
-        end
-      end
-    end
-    inner_regsubst(target, Regexp.compile(pattern, re_flags, encoding), replacement, operation)
-  end
-
-  def regsubst_regexp(target, pattern, replacement, flags = nil)
-    pattern = (pattern.pattern || '') if pattern.is_a?(Puppet::Pops::Types::PRegexpType)
-    inner_regsubst(target, pattern, replacement, operation = flags == 'G' ? :gsub : :sub)
-  end
-
-  def inner_regsubst(target, re, replacement, op)
-    target.respond_to?(op) ? target.send(op, re, replacement) : target.collect { |e| e.send(op, re, replacement) }
-  end
-  private :inner_regsubst
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/reverse_each.rb

@@ -1,82 +0,0 @@
-# Reverses the order of the elements of something that is iterable and optionally runs a
-# [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
-# element.
-#
-# This function takes one to two arguments.
-#
-# 1. An `Iterable` that the function will iterate over.
-# 2. An optional lambda, which the function calls for each element in the first argument. It must
-# request one parameter.
-#
-# @example Using the `reverse_each` function
-#
-# `$data.reverse_each |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# or
-#
-# `$reverse_data = $data.reverse_each`
-#
-# or
-#
-# `reverse_each($data) |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# or
-#
-# `$reverse_data = reverse_each($data)`
-#
-# When no second argument is present, Puppet returns an `Iterable` that represents the reverse
-# order of its first argument. This allows methods on `Iterable` to be chained.
-#
-# When a lamdba is given as the second argument, Puppet iterates the first argument in reverse
-# order and passes each value in turn to the lambda, then returns `undef`.
-#
-# @example Using the `reverse_each` function with an array and a one-parameter lambda
-#
-# ~~~ puppet
-# # Puppet will log a notice for each of the three items in $data in reverse order.
-# $data = [1,2,3]
-# $data.reverse_each |$item| { notice($item) }
-#
-# ~~~
-#
-# When no second argument is present, Puppet returns a new `Iterable` which allows it to
-# be directly chained into another function that takes an `Iterable` as an argument.
-#
-# @example Using the `reverse_each` function chained with a `map` function.
-#
-# # For the array $data, return an array containing each value multiplied by 10 in reverse order
-# $data = [1,2,3]
-# $transformed_data = $data.reverse_each.map |$item| { $item * 10 }
-# # $transformed_data is set to [30,20,10]
-# ~~~
-#
-# @example The same example using `reverse_each` function chained with a `map` in alternative syntax
-#
-# # For the array $data, return an array containing each value multiplied by 10 in reverse order
-# $data = [1,2,3]
-# $transformed_data = map(reverse_each($data)) |$item| { $item * 10 }
-# # $transformed_data is set to [30,20,10]
-# ~~~
-#
-# @since 4.4.0
-#
-Puppet::Functions.create_function(:reverse_each) do
-  dispatch :reverse_each do
-    param 'Iterable', :iterable
-  end
-
-  dispatch :reverse_each_block do
-    param 'Iterable', :iterable
-    block_param 'Callable[1,1]', :block
-  end
-
-  def reverse_each(iterable)
-    # produces an Iterable
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each
-  end
-
-  def reverse_each_block(iterable, &block)
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).reverse_each(&block)
-    nil
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/scanf.rb

@@ -1,44 +0,0 @@
-# Scans a string and returns an array of one or more converted values based on the given format string.
-# See the documenation of Ruby's String#scanf method for details about the supported formats (which
-# are similar but not identical to the formats used in Puppet's `sprintf` function.)
-#
-# This function takes two mandatory arguments: the first is the string to convert, and the second is
-# the format string. The result of the scan is an array, with each sucessfully scanned and transformed value.
-# The scanning stops if a scan is unsuccesful, and the scanned result up to that point is returned. If there
-# was no succesful scan, the result is an empty array.
-#
-#    "42".scanf("%i")
-#
-# You can also optionally pass a lambda to scanf, to do additional validation or processing.
-#
-#
-#     "42".scanf("%i") |$x| {
-#       unless $x[0] =~ Integer {
-#         fail "Expected a well formed integer value, got '$x[0]'"
-#       }
-#       $x[0]
-#     }
-#
-#
-#
-#
-#
-# @since 4.0.0
-#
-Puppet::Functions.create_function(:scanf) do
-  require 'scanf'
-
-  dispatch :scanf do
-    param 'String', :data
-    param 'String', :format
-    optional_block_param
-  end
-
-  def scanf(data, format)
-    result = data.scanf(format)
-    if block_given?
-      result = yield(result)
-    end
-    result
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/step.rb

@@ -1,88 +0,0 @@
-# Provides stepping with given interval over elements in an iterable and optionally runs a
-# [lambda](http://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html) for each
-# element.
-#
-# This function takes two to three arguments.
-#
-# 1. An 'Iterable' that the function will iterate over.
-# 2. An `Integer` step factor. This must be a positive integer.
-# 3. An optional lambda, which the function calls for each element in the interval. It must
-# request one parameter.
-#
-# @example Using the `step` function
-#
-# `$data.step(<n>) |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# or
-#
-# `$stepped_data = $data.step(<n>)`
-#
-# or
-#
-# `step($data, <n>) |$parameter| { <PUPPET CODE BLOCK> }`
-#
-# or
-#
-# `$stepped_data = step($data, <n>)`
-#
-# When no block is given, Puppet returns an `Iterable` that yields the first element and every nth successor
-# element, from its first argument. This allows functions on iterables to be chained.
-#
-# When a block is given, Puppet iterates and calls the block with the first element and then with
-# every nth successor element. It then returns `undef`.
-#
-# @example Using the `step` function with an array, a step factor, and a one-parameter block
-#
-# ~~~ puppet
-# # For the array $data, call a block with the first element and then with each 3rd successor element
-# $data = [1,2,3,4,5,6,7,8]
-# $data.step(3) |$item| {
-#  notice($item)
-# }
-# # Puppet notices the values '1', '4', '7'.
-# ~~~
-#
-# When no block is given, Puppet returns a new `Iterable` which allows it to be directly chained into
-# another function that takes an `Iterable` as an argument.
-#
-# @example Using the `step` function chained with a `map` function.
-#
-# # For the array $data, return an array, set to the first element and each 5th successor element, in reverse
-# # order multiplied by 10
-# $data = Integer[0,20]
-# $transformed_data = $data.step(5).map |$item| { $item * 10 }
-# # $transformed_data contains [0,50,100,150,200]
-# ~~~
-#
-# @example The same example using `step` function chained with a `map` in alternative syntax
-#
-# # For the array $data, return an array, set to the first and each 5th successor, in reverse order, multiplied by 10
-# $data = Integer[0,20]
-# $transformed_data = map(step($data, 5)) |$item| { $item * 10 }
-# # $transformed_data contains [0,50,100,150,200]
-# ~~~
-#
-# @since 4.4.0
-#
-Puppet::Functions.create_function(:step) do
-  dispatch :step do
-    param 'Iterable', :iterable
-    param 'Integer[1]', :step
-  end
-
-  dispatch :step_block do
-    param 'Iterable', :iterable
-    param 'Integer[1]', :step
-    block_param 'Callable[1,1]', :block
-  end
-
-  def step(iterable, step)
-    # produces an Iterable
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step)
-  end
-
-  def step_block(iterable, step, &block)
-    Puppet::Pops::Types::Iterable.asserted_iterable(self, iterable).step(step, &block)
-    nil
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/then.rb

@@ -1,74 +0,0 @@
-# Call a [lambda](https://docs.puppet.com/puppet/latest/reference/lang_lambdas.html)
-# with the given argument unless the argument is undef. Return undef if argument is
-# undef, and otherwise the result of giving the argument to the lambda.
-#
-# This is useful to process a sequence of operations where an intermediate
-# result may be undef (which makes the entire sequence undef).
-# The `then` function is especially useful with the function `dig` which
-# performs in a similar way "digging out" a value in a complex structure.
-#
-# @example Using `then`
-#
-# ~~~ puppet
-# $data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
-# notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
-# ~~~
-#
-# Would notice the value 200
-#
-# Contrast this with:
-#
-# ~~~ puppet
-# $data = {a => { b => [{x => 10, y => 20}, {ex => 100, why => 200}]}}
-# notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
-# ~~~
-#
-# Which would notice undef since the last lookup of 'x' results in `undef` which
-# is returned (without calling the block).
-#
-# As a result there was no need for conditional logic or a temporary (non local) 
-# variable as the result is now either the wanted value (x) multiplied
-# by 2 or `undef`.
-#
-# Calls to `then` can be chained. In the next example, a structure is using an offset that
-# is using 1 as the index to the first element (instead of 0 which is used in the language).
-# We are not sure if user input actually contains an index at all, or if it is
-# outside the range of available names.
-#
-# ~~~ puppet
-# # Names to choose from
-# $names = ['Ringo', 'Paul', 'George', 'John']
-#
-# # structure where 'beatle 2' is wanted (but where the number refers
-# # to 'Paul' because input comes from a source using 1 for the first
-# # element).
-#
-# $data = [202, { beatle => 2 }]
-# $picked = assert_type(String,
-#   # the data we are interested in is the second in the array,
-#   # a hash, where we want the value of the key 'beatle'
-#   $data.dig(1, 'beatle')
-#     # and we want the index in $names before the given index
-#     .then |$x| { $names[$x-1] }
-#     # so we can construct a string with that beatle's name
-#     .then |$x| { "Picked Beatle '${x}'" }
-# )
-#
-# ~~~ puppet
-#
-# Would notice "Picked Beatle 'Paul'", and would raise an error if the result
-# was not a String.
-#
-# @since 4.5.0
-#
-Puppet::Functions.create_function(:then) do
-  dispatch :then do
-    param 'Any', :arg
-    block_param 'Callable[1,1]', :block
-  end
-
-  def then(arg)
-    return nil if arg.nil?
-    yield(arg)
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/functions/type.rb

@@ -1,70 +0,0 @@
-# Returns the data type of a given value with a given degree of generality.
-#
-# @example Using `type()`
-#
-# ~~~ puppet
-# notice type(42) =~ Type[Integer]
-# ~~~
-#
-# Would notice true
-#
-# By default, the best possible inference is made where all details are retained.
-# This is good when the type is used for further type calculations but is overwhelmingly
-# rich in information if it is used in a error message.
-#
-# The optional argument `inference_method` may be given as (from lowest to highest fidelity):
-#
-# * `generalized` - reduces to common type and drops size constraints
-# * `reduced` - reduces to common type in collections
-# * `detailed` - (default) all details about inferred types is retained
-#
-# @example Using `type()` with different qualities:
-#
-# ~~~ puppet
-# notice type([3.14, 42], generalized)
-# notice type([3.14, 42], reduced)
-# notice type([3.14, 42], detailed)
-# notice type([3.14, 42])
-# ~~~
-#
-# Would notice the four values:
-#
-# 1. 'Array[Numeric]'
-# 2. 'Array[Numeric, 2, 2]'
-# 3. 'Tuple[Float[3.14], Integer[42,42]]]'
-# 4. 'Tuple[Float[3.14], Integer[42,42]]]'
-#
-# @param value [Any] - the value for which data type is returned
-# @param inference_type[Enum[generalized, reduced, detailed]] inference_type
-# @returns [Type] - the inferred type
-#
-# @since 4.4.0
-#
-Puppet::Functions.create_function(:type) do
-  dispatch :type_detailed do
-    param 'Any', :value
-    optional_param 'Enum[detailed]', :inference_method
-  end
-
-  dispatch :type_parameterized do
-    param 'Any', :value
-    param 'Enum[reduced]', :inference_method
-  end
-
-  dispatch :type_generalized do
-    param 'Any', :value
-    param 'Enum[generalized]', :inference_method
-  end
-
-  def type_detailed(value, _ = nil)
-    Puppet::Pops::Types::TypeCalculator.infer_set(value)
-  end
-
-  def type_parameterized(value, _)
-    Puppet::Pops::Types::TypeCalculator.infer(value)
-  end
-
-  def type_generalized(value, _)
-    Puppet::Pops::Types::TypeCalculator.infer(value).generalize
-  end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/graph/simple_graph.rb

@@ -1,562 +0,0 @@
-require 'puppet/external/dot'
-require 'puppet/relationship'
-require 'set'
-
-# A hopefully-faster graph class to replace the use of GRATR.
-class Puppet::Graph::SimpleGraph
-  #
-  # All public methods of this class must maintain (assume ^ ensure) the following invariants, where "=~=" means
-  # equiv. up to order:
-  #
-  #   @in_to.keys =~= @out_to.keys =~= all vertices
-  #   @in_to.values.collect { |x| x.values }.flatten =~= @out_from.values.collect { |x| x.values }.flatten =~= all edges
-  #   @in_to[v1][v2] =~= @out_from[v2][v1] =~= all edges from v1 to v2
-  #   @in_to   [v].keys =~= vertices with edges leading to   v
-  #   @out_from[v].keys =~= vertices with edges leading from v
-  #   no operation may shed reference loops (for gc)
-  #   recursive operation must scale with the depth of the spanning trees, or better (e.g. no recursion over the set
-  #       of all vertices, etc.)
-  #
-  # This class is intended to be used with DAGs.  However, if the
-  # graph has a cycle, it will not cause non-termination of any of the
-  # algorithms.
-  #
-  def initialize
-    @in_to = {}
-    @out_from = {}
-    @upstream_from = {}
-    @downstream_from = {}
-  end
-
-  # Clear our graph.
-  def clear
-    @in_to.clear
-    @out_from.clear
-    @upstream_from.clear
-    @downstream_from.clear
-  end
-
-  # Which resources depend upon the given resource.
-  def dependencies(resource)
-    vertex?(resource) ? upstream_from_vertex(resource).keys : []
-  end
-
-  def dependents(resource)
-    vertex?(resource) ? downstream_from_vertex(resource).keys : []
-  end
-
-  # Whether our graph is directed.  Always true.  Used to produce dot files.
-  def directed?
-    true
-  end
-
-  # Determine all of the leaf nodes below a given vertex.
-  def leaves(vertex, direction = :out)
-    tree_from_vertex(vertex, direction).keys.find_all { |c| adjacent(c, :direction => direction).empty? }
-  end
-
-  # Collect all of the edges that the passed events match.  Returns
-  # an array of edges.
-  def matching_edges(event, base = nil)
-    source = base || event.resource
-
-    unless vertex?(source)
-      Puppet.warning "Got an event from invalid vertex #{source.ref}"
-      return []
-    end
-    # Get all of the edges that this vertex should forward events
-    # to, which is the same thing as saying all edges directly below
-    # This vertex in the graph.
-    @out_from[source].values.flatten.find_all { |edge| edge.match?(event.name) }
-  end
-
-  # Return a reversed version of this graph.
-  def reversal
-    result = self.class.new
-    vertices.each { |vertex| result.add_vertex(vertex) }
-    edges.each do |edge|
-      result.add_edge edge.class.new(edge.target, edge.source, edge.label)
-    end
-    result
-  end
-
-  # Return the size of the graph.
-  def size
-    vertices.size
-  end
-
-  def to_a
-    vertices
-  end
-
-  # This is a simple implementation of Tarjan's algorithm to find strongly
-  # connected components in the graph; this is a fairly ugly implementation,
-  # because I can't just decorate the vertices themselves.
-  #
-  # This method has an unhealthy relationship with the find_cycles_in_graph
-  # method below, which contains the knowledge of how the state object is
-  # maintained.
-  def tarjan(root, s)
-    # initialize the recursion stack we use to work around the nasty lack of a
-    # decent Ruby stack.
-    recur = [{ :node => root }]
-
-    while not recur.empty? do
-      frame = recur.last
-      vertex = frame[:node]
-
-      case frame[:step]
-      when nil then
-        s[:index][vertex]   = s[:number]
-        s[:lowlink][vertex] = s[:number]
-        s[:number]          = s[:number] + 1
-
-        s[:stack].push(vertex)
-        s[:seen][vertex] = true
-
-        frame[:children] = adjacent(vertex)
-        frame[:step]     = :children
-
-      when :children then
-        if frame[:children].length > 0 then
-          child = frame[:children].shift
-          if ! s[:index][child] then
-            # Never seen, need to recurse.
-            frame[:step] = :after_recursion
-            frame[:child] = child
-            recur.push({ :node => child })
-          elsif s[:seen][child] then
-            s[:lowlink][vertex] = [s[:lowlink][vertex], s[:index][child]].min
-          end
-        else
-          if s[:lowlink][vertex] == s[:index][vertex] then
-            this_scc = []
-            begin
-              top = s[:stack].pop
-              s[:seen][top] = false
-              this_scc << top
-            end until top == vertex
-            s[:scc] << this_scc
-          end
-          recur.pop               # done with this node, finally.
-        end
-
-      when :after_recursion then
-        s[:lowlink][vertex] = [s[:lowlink][vertex], s[:lowlink][frame[:child]]].min
-        frame[:step] = :children
-
-      else
-        fail "#{frame[:step]} is an unknown step"
-      end
-    end
-  end
-
-  # Find all cycles in the graph by detecting all the strongly connected
-  # components, then eliminating everything with a size of one as
-  # uninteresting - which it is, because it can't be a cycle. :)
-  #
-  # This has an unhealthy relationship with the 'tarjan' method above, which
-  # it uses to implement the detection of strongly connected components.
-  def find_cycles_in_graph
-    state = {
-      :number => 0, :index => {}, :lowlink => {}, :scc => [],
-      :stack => [], :seen => {}
-    }
-
-    # we usually have a disconnected graph, must walk all possible roots
-    vertices.each do |vertex|
-      if ! state[:index][vertex] then
-        tarjan vertex, state
-      end
-    end
-
-    # To provide consistent results to the user, given that a hash is never
-    # assured to return the same order, and given our graph processing is
-    # based on hash tables, we need to sort the cycles internally, as well as
-    # the set of cycles.
-    #
-    # Given we are in a failure state here, any extra cost is more or less
-    # irrelevant compared to the cost of a fix - which is on a human
-    # time-scale.
-    state[:scc].select do |component|
-      multi_vertex_component?(component) || single_vertex_referring_to_self?(component)
-    end.map do |component|
-      component.sort
-    end.sort
-  end
-
-  # Perform a BFS on the sub graph representing the cycle, with a view to
-  # generating a sufficient set of paths to report the cycle meaningfully, and
-  # ideally usefully, for the end user.
-  #
-  # BFS is preferred because it will generally report the shortest paths
-  # through the graph first, which are more likely to be interesting to the
-  # user.  I think; it would be interesting to verify that. --daniel 2011-01-23
-  def paths_in_cycle(cycle, max_paths = 1)
-    raise ArgumentError, "negative or zero max_paths" if max_paths < 1
-
-    # Calculate our filtered outbound vertex lists...
-    adj = {}
-    cycle.each do |vertex|
-      adj[vertex] = adjacent(vertex).select{|s| cycle.member? s}
-    end
-
-    found = []
-
-    # frame struct is vertex, [path]
-    stack = [[cycle.first, []]]
-    while frame = stack.shift do
-      if frame[1].member?(frame[0]) then
-        found << frame[1] + [frame[0]]
-        break if found.length >= max_paths
-      else
-        adj[frame[0]].each do |to|
-          stack.push [to, frame[1] + [frame[0]]]
-        end
-      end
-    end
-
-    return found.sort
-  end
-
-  def report_cycles_in_graph
-    cycles = find_cycles_in_graph
-    n = cycles.length           # where is "pluralize"? --daniel 2011-01-22
-    return if n == 0
-    s = n == 1 ? '' : 's'
-
-    message = "Found #{n} dependency cycle#{s}:\n"
-    cycles.each do |cycle|
-      paths = paths_in_cycle(cycle)
-      message += paths.map{ |path| '(' + path.join(" => ") + ')'}.join("\n") + "\n"
-    end
-
-    if Puppet[:graph] then
-      filename = write_cycles_to_graph(cycles)
-      message += "Cycle graph written to #{filename}."
-    else
-      message += "Try the '--graph' option and opening the "
-      message += "resulting '.dot' file in OmniGraffle or GraphViz"
-    end
-
-    raise Puppet::Error, message
-  end
-
-  def write_cycles_to_graph(cycles)
-    # This does not use the DOT graph library, just writes the content
-    # directly.  Given the complexity of this, there didn't seem much point
-    # using a heavy library to generate exactly the same content. --daniel 2011-01-27
-    Puppet.settings.use(:graphing)
-
-    graph = ["digraph Resource_Cycles {"]
-    graph << '  label = "Resource Cycles"'
-
-    cycles.each do |cycle|
-      paths_in_cycle(cycle, 10).each do |path|
-        graph << path.map { |v| '"' + v.to_s.gsub(/"/, '\\"') + '"' }.join(" -> ")
-      end
-    end
-
-    graph << '}'
-
-    filename = File.join(Puppet[:graphdir], "cycles.dot")
-    File.open(filename, "w") { |f| f.puts graph }
-    return filename
-  end
-
-  # Add a new vertex to the graph.
-  def add_vertex(vertex)
-    @in_to[vertex]    ||= {}
-    @out_from[vertex] ||= {}
-  end
-
-  # Remove a vertex from the graph.
-  def remove_vertex!(v)
-    return unless vertex?(v)
-    @upstream_from.clear
-    @downstream_from.clear
-    (@in_to[v].values+@out_from[v].values).flatten.each { |e| remove_edge!(e) }
-    @in_to.delete(v)
-    @out_from.delete(v)
-  end
-
-  # Test whether a given vertex is in the graph.
-  def vertex?(v)
-    @in_to.include?(v)
-  end
-
-  # Return a list of all vertices.
-  def vertices
-    @in_to.keys
-  end
-
-  # Add a new edge.  The graph user has to create the edge instance,
-  # since they have to specify what kind of edge it is.
-  def add_edge(e,*a)
-    return add_relationship(e,*a) unless a.empty?
-    @upstream_from.clear
-    @downstream_from.clear
-    add_vertex(e.source)
-    add_vertex(e.target)
-    # Avoid multiple lookups here. This code is performance critical
-    arr = (@in_to[e.target][e.source] ||= [])
-    arr << e unless arr.include?(e)
-    arr = (@out_from[e.source][e.target] ||= [])
-    arr << e unless arr.include?(e)
-  end
-
-  def add_relationship(source, target, label = nil)
-    add_edge Puppet::Relationship.new(source, target, label)
-  end
-
-  # Find all matching edges.
-  def edges_between(source, target)
-    (@out_from[source] || {})[target] || []
-  end
-
-  # Is there an edge between the two vertices?
-  def edge?(source, target)
-    vertex?(source) and vertex?(target) and @out_from[source][target]
-  end
-
-  def edges
-    @in_to.values.collect { |x| x.values }.flatten
-  end
-
-  def each_edge
-    @in_to.each { |t,ns| ns.each { |s,es| es.each { |e| yield e }}}
-  end
-
-  # Remove an edge from our graph.
-  def remove_edge!(e)
-    if edge?(e.source,e.target)
-      @upstream_from.clear
-      @downstream_from.clear
-      @in_to   [e.target].delete e.source if (@in_to   [e.target][e.source] -= [e]).empty?
-      @out_from[e.source].delete e.target if (@out_from[e.source][e.target] -= [e]).empty?
-    end
-  end
-
-  # Find adjacent edges.
-  def adjacent(v, options = {})
-    return [] unless ns = (options[:direction] == :in) ? @in_to[v] : @out_from[v]
-    (options[:type] == :edges) ? ns.values.flatten : ns.keys
-  end
-
-  # Just walk the tree and pass each edge.
-  def walk(source, direction)
-    # Use an iterative, breadth-first traversal of the graph. One could do
-    # this recursively, but Ruby's slow function calls and even slower
-    # recursion make the shorter, recursive algorithm cost-prohibitive.
-    stack = [source]
-    seen = Set.new
-    until stack.empty?
-      node = stack.shift
-      next if seen.member? node
-      connected = adjacent(node, :direction => direction)
-      connected.each do |target|
-        yield node, target
-      end
-      stack.concat(connected)
-      seen << node
-    end
-  end
-
-  # A different way of walking a tree, and a much faster way than the
-  # one that comes with GRATR.
-  def tree_from_vertex(start, direction = :out)
-    predecessor={}
-    walk(start, direction) do |parent, child|
-      predecessor[child] = parent
-    end
-    predecessor
-  end
-
-  def downstream_from_vertex(v)
-    return @downstream_from[v] if @downstream_from[v]
-    result = @downstream_from[v] = {}
-    @out_from[v].keys.each do |node|
-      result[node] = 1
-      result.update(downstream_from_vertex(node))
-    end
-    result
-  end
-
-  def direct_dependents_of(v)
-    (@out_from[v] || {}).keys
-  end
-
-  def upstream_from_vertex(v)
-    return @upstream_from[v] if @upstream_from[v]
-    result = @upstream_from[v] = {}
-    @in_to[v].keys.each do |node|
-      result[node] = 1
-      result.update(upstream_from_vertex(node))
-    end
-    result
-  end
-
-  def direct_dependencies_of(v)
-    (@in_to[v] || {}).keys
-  end
-
-  # Return an array of the edge-sets between a series of n+1 vertices (f=v0,v1,v2...t=vn)
-  #   connecting the two given verticies.  The ith edge set is an array containing all the
-  #   edges between v(i) and v(i+1); these are (by definition) never empty.
-  #
-  #     * if f == t, the list is empty
-  #     * if they are adjacent the result is an array consisting of
-  #       a single array (the edges from f to t)
-  #     * and so on by induction on a vertex m between them
-  #     * if there is no path from f to t, the result is nil
-  #
-  # This implementation is not particularly efficient; it's used in testing where clarity
-  #   is more important than last-mile efficiency.
-  #
-  def path_between(f,t)
-    if f==t
-      []
-    elsif direct_dependents_of(f).include?(t)
-      [edges_between(f,t)]
-    elsif dependents(f).include?(t)
-      m = (dependents(f) & direct_dependencies_of(t)).first
-      path_between(f,m) + path_between(m,t)
-    else
-      nil
-    end
-  end
-
-  # LAK:FIXME This is just a paste of the GRATR code with slight modifications.
-
-  # Return a DOT::DOTDigraph for directed graphs or a DOT::DOTSubgraph for an
-  # undirected Graph.  _params_ can contain any graph property specified in
-  # rdot.rb. If an edge or vertex label is a kind of Hash then the keys
-  # which match +dot+ properties will be used as well.
-  def to_dot_graph (params = {})
-    params['name'] ||= self.class.name.gsub(/:/,'_')
-    fontsize   = params['fontsize'] ? params['fontsize'] : '8'
-    graph      = (directed? ? DOT::DOTDigraph : DOT::DOTSubgraph).new(params)
-    edge_klass = directed? ? DOT::DOTDirectedEdge : DOT::DOTEdge
-    vertices.each do |v|
-      name = v.ref
-      params = {'name'     => '"'+name+'"',
-        'fontsize' => fontsize,
-        'label'    => name}
-      v_label = v.ref
-      params.merge!(v_label) if v_label and v_label.kind_of? Hash
-      graph << DOT::DOTNode.new(params)
-    end
-    edges.each do |e|
-      params = {'from'     => '"'+ e.source.ref + '"',
-        'to'       => '"'+ e.target.ref + '"',
-        'fontsize' => fontsize }
-      e_label = e.ref
-      params.merge!(e_label) if e_label and e_label.kind_of? Hash
-      graph << edge_klass.new(params)
-    end
-    graph
-  end
-
-  # Output the dot format as a string
-  def to_dot (params={}) to_dot_graph(params).to_s; end
-
-  # Produce the graph files if requested.
-  def write_graph(name)
-    return unless Puppet[:graph]
-
-    Puppet.settings.use(:graphing)
-
-    file = File.join(Puppet[:graphdir], "#{name}.dot")
-    File.open(file, "w") { |f|
-      f.puts to_dot("name" => name.to_s.capitalize)
-    }
-  end
-
-  # This flag may be set to true to use the new YAML serialzation
-  # format (where @vertices is a simple list of vertices rather than a
-  # list of VertexWrapper objects).  Deserialization supports both
-  # formats regardless of the setting of this flag.
-  class << self
-    attr_accessor :use_new_yaml_format
-  end
-  self.use_new_yaml_format = false
-
-  # Stub class to allow graphs to be represented in YAML using the old
-  # (version 2.6) format.
-  class VertexWrapper
-    attr_reader :vertex, :adjacencies
-    def initialize(vertex, adjacencies)
-      @vertex = vertex
-      @adjacencies = adjacencies
-    end
-
-    def inspect
-      { :@adjacencies => @adjacencies, :@vertex => @vertex.to_s }.inspect
-    end
-  end
-
-  # instance_variable_get is used by YAML.dump to get instance
-  # variables.  Override it so that we can simulate the presence of
-  # instance variables @edges and @vertices for serialization.
-  def instance_variable_get(v)
-    case v.to_s
-    when '@edges' then
-      edges
-    when '@vertices' then
-      if self.class.use_new_yaml_format
-        vertices
-      else
-        result = {}
-        vertices.each do |vertex|
-          adjacencies = {}
-          [:in, :out].each do |direction|
-            adjacencies[direction] = {}
-            adjacent(vertex, :direction => direction, :type => :edges).each do |edge|
-              other_vertex = direction == :in ? edge.source : edge.target
-              (adjacencies[direction][other_vertex] ||= Set.new).add(edge)
-            end
-          end
-          result[vertex] = Puppet::Graph::SimpleGraph::VertexWrapper.new(vertex, adjacencies)
-        end
-        result
-      end
-    else
-      super(v)
-    end
-  end
-
-  def to_yaml_properties
-    (super + [:@vertices, :@edges] -
-     [:@in_to, :@out_from, :@upstream_from, :@downstream_from]).uniq
-  end
-
-  def yaml_initialize(tag, var)
-    initialize()
-    vertices = var.delete('vertices')
-    edges = var.delete('edges')
-    if vertices.is_a?(Hash)
-      # Support old (2.6) format
-      vertices = vertices.keys
-    end
-    vertices.each { |v| add_vertex(v) }
-    edges.each { |e| add_edge(e) }
-    var.each do |varname, value|
-      instance_variable_set("@#{varname}", value)
-    end
-  end
-
-  def multi_vertex_component?(component)
-    component.length > 1
-  end
-  private :multi_vertex_component?
-
-  def single_vertex_referring_to_self?(component)
-    if component.length == 1
-      vertex = component[0]
-      adjacent(vertex).include?(vertex)
-    else
-      false
-    end
-  end
-  private :single_vertex_referring_to_self?
-end