puppet-retrospec 0.7.0 → 0.7.2

data/vendor/gems/puppet-3.7.3/lib/puppet/confine.rb

@@ -0,0 +1,80 @@
+# The class that handles testing whether our providers
+# actually work or not.
+require 'puppet/util'
+
+class Puppet::Confine
+  include Puppet::Util
+
+  @tests = {}
+
+  class << self
+    attr_accessor :name
+  end
+
+  def self.inherited(klass)
+    name = klass.to_s.split("::").pop.downcase.to_sym
+    raise "Test #{name} is already defined" if @tests.include?(name)
+
+    klass.name = name
+
+    @tests[name] = klass
+  end
+
+  def self.test(name)
+    unless @tests[name]
+      begin
+        require "puppet/confine/#{name}"
+      rescue LoadError => detail
+        unless detail.to_s =~ /No such file|cannot load such file/i
+          warn "Could not load confine test '#{name}': #{detail}"
+        end
+        # Could not find file
+      end
+    end
+    @tests[name]
+  end
+
+  attr_reader :values
+
+  # Mark that this confine is used for testing binary existence.
+  attr_accessor :for_binary
+  def for_binary?
+    for_binary
+  end
+
+  # Used for logging.
+  attr_accessor :label
+
+  def initialize(values)
+    values = [values] unless values.is_a?(Array)
+    @values = values
+  end
+
+  # Provide a hook for the message when there's a failure.
+  def message(value)
+    ""
+  end
+
+  # Collect the results of all of them.
+  def result
+    values.collect { |value| pass?(value) }
+  end
+
+  # Test whether our confine matches.
+  def valid?
+    values.each do |value|
+      unless pass?(value)
+        Puppet.debug(label + ": " + message(value))
+        return false
+      end
+    end
+
+    return true
+  ensure
+    reset
+  end
+
+  # Provide a hook for subclasses.
+  def reset
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/confine/any.rb

@@ -0,0 +1,26 @@
+class Puppet::Confine::Any < Puppet::Confine
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
+
+  def pass?(value)
+    !! value
+  end
+
+  def message(value)
+    "0 confines (of #{value.length}) were true"
+  end
+
+  def summary
+    result.find_all { |v| v == true }.length
+  end
+
+  def valid?
+    if @values.any? { |value| pass?(value) }
+      true
+    else
+      Puppet.debug("#{label}: #{message(@values)}")
+      false
+    end
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/confine/exists.rb

@@ -0,0 +1,19 @@
+require 'puppet/confine'
+
+class Puppet::Confine::Exists < Puppet::Confine
+  def self.summarize(confines)
+    confines.inject([]) { |total, confine| total + confine.summary }
+  end
+
+  def pass?(value)
+    value && (for_binary? ? which(value) : Puppet::FileSystem.exist?(value))
+  end
+
+  def message(value)
+    "file #{value} does not exist"
+  end
+
+  def summary
+    result.zip(values).inject([]) { |array, args| val, f = args; array << f unless val; array }
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/confine/false.rb

@@ -0,0 +1,19 @@
+require 'puppet/confine'
+
+class Puppet::Confine::False < Puppet::Confine
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
+
+  def pass?(value)
+    ! value
+  end
+
+  def message(value)
+    "true value when expecting false"
+  end
+
+  def summary
+    result.find_all { |v| v == false }.length
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/confine/feature.rb

@@ -0,0 +1,17 @@
+require 'puppet/confine'
+
+class Puppet::Confine::Feature < Puppet::Confine
+  def self.summarize(confines)
+    confines.collect { |c| c.values }.flatten.uniq.find_all { |value| ! confines[0].pass?(value) }
+  end
+
+  # Is the named feature available?
+  def pass?(value)
+    Puppet.features.send(value.to_s + "?")
+  end
+
+  def message(value)
+    "feature #{value} is missing"
+  end
+end
+

data/vendor/gems/puppet-3.7.3/lib/puppet/confine/true.rb

@@ -0,0 +1,20 @@
+require 'puppet/confine'
+
+class Puppet::Confine::True < Puppet::Confine
+  def self.summarize(confines)
+    confines.inject(0) { |count, confine| count + confine.summary }
+  end
+
+  def pass?(value)
+    # Double negate, so we only get true or false.
+    ! ! value
+  end
+
+  def message(value)
+    "false value when expecting true"
+  end
+
+  def summary
+    result.find_all { |v| v == true }.length
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/confine/variable.rb

@@ -0,0 +1,59 @@
+require 'puppet/confine'
+
+# Require a specific value for a variable, either a Puppet setting
+# or a Facter value.  This class is a bit weird because the name
+# is set explicitly by the ConfineCollection class -- from this class,
+# it's not obvious how the name would ever get set.
+class Puppet::Confine::Variable < Puppet::Confine
+  # Provide a hash summary of failing confines -- the key of the hash
+  # is the name of the confine, and the value is the missing yet required values.
+  # Only returns failed values, not all required values.
+  def self.summarize(confines)
+    result = Hash.new { |hash, key| hash[key] = [] }
+    confines.inject(result) { |total, confine| total[confine.name] += confine.values unless confine.valid?; total }
+  end
+
+  # This is set by ConfineCollection.
+  attr_accessor :name
+
+  # Retrieve the value from facter
+  def facter_value
+    @facter_value ||= ::Facter.value(name).to_s.downcase
+  end
+
+  def initialize(values)
+    super
+    @values = @values.collect { |v| v.to_s.downcase }
+  end
+
+  def message(value)
+    "facter value '#{test_value}' for '#{self.name}' not in required list '#{values.join(",")}'"
+  end
+
+  # Compare the passed-in value to the retrieved value.
+  def pass?(value)
+    test_value.downcase.to_s == value.to_s.downcase
+  end
+
+  def reset
+    # Reset the cache.  We want to cache it during a given
+    # run, but not across runs.
+    @facter_value = nil
+  end
+
+  def valid?
+    @values.include?(test_value.to_s.downcase)
+  ensure
+    reset
+  end
+
+  private
+
+  def setting?
+    Puppet.settings.valid?(name)
+  end
+
+  def test_value
+    setting? ? Puppet.settings[name] : facter_value
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/confine_collection.rb

@@ -0,0 +1,50 @@
+# Manage a collection of confines, returning a boolean or
+# helpful information.
+require 'puppet/confine'
+
+class Puppet::ConfineCollection
+  def confine(hash)
+    if hash.include?(:for_binary)
+      for_binary = true
+      hash.delete(:for_binary)
+    else
+      for_binary = false
+    end
+    hash.each do |test, values|
+      if klass = Puppet::Confine.test(test)
+        @confines << klass.new(values)
+        @confines[-1].for_binary = true if for_binary
+      else
+        confine = Puppet::Confine.test(:variable).new(values)
+        confine.name = test
+        @confines << confine
+      end
+      @confines[-1].label = self.label
+    end
+  end
+
+  attr_reader :label
+  def initialize(label)
+    @label = label
+    @confines = []
+  end
+
+  # Return a hash of the whole confine set, used for the Provider
+  # reference.
+  def summary
+    confines = Hash.new { |hash, key| hash[key] = [] }
+    @confines.each { |confine| confines[confine.class] << confine }
+    result = {}
+    confines.each do |klass, list|
+      value = klass.summarize(list)
+      next if (value.respond_to?(:length) and value.length == 0) or (value == 0)
+      result[klass.name] = value
+
+    end
+    result
+  end
+
+  def valid?
+    ! @confines.detect { |c| ! c.valid? }
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/confiner.rb

@@ -0,0 +1,46 @@
+require 'puppet/confine_collection'
+
+# The Confiner module contains methods for managing a Provider's confinement (suitability under given
+# conditions). The intent is to include this module in an object where confinement management is wanted.
+# It lazily adds an instance variable `@confine_collection` to the object where it is included.
+#
+module Puppet::Confiner
+  # Confines a provider to be suitable only under the given conditions.
+  # The hash describes a confine using mapping from symbols to values or predicate code.
+  #
+  # * _fact_name_ => value of fact (or array of facts)
+  # * `:exists` => the path to an existing file
+  # * `:true` => a predicate code block returning true
+  # * `:false` => a predicate code block returning false
+  # * `:feature` => name of system feature that must be present
+  # * `:any` => an array of expressions that will be ORed together
+  #
+  # @example
+  #   confine :operatingsystem => [:redhat, :fedora]
+  #   confine :true { ... }
+  #
+  # @param hash [Hash<{Symbol => Object}>] hash of confines
+  # @return [void]
+  # @api public
+  #
+  def confine(hash)
+    confine_collection.confine(hash)
+  end
+
+  # @return [Puppet::ConfineCollection] the collection of confines
+  # @api private
+  #
+  def confine_collection
+    @confine_collection ||= Puppet::ConfineCollection.new(self.to_s)
+  end
+
+  # Checks whether this implementation is suitable for the current platform (or returns a summary
+  # of all confines if short == false).
+  # @return [Boolean. Hash] Returns whether the confines are all valid (if short == true), or a hash of all confines
+  #   if short == false.
+  # @api public
+  #
+  def suitable?(short = true)
+    return(short ? confine_collection.valid? : confine_collection.summary)
+  end
+end

data/vendor/gems/puppet-3.7.3/lib/puppet/context.rb

@@ -0,0 +1,101 @@
+# Puppet::Context is a system for tracking services and contextual information
+# that puppet needs to be able to run. Values are "bound" in a context when it is created
+# and cannot be changed; however a child context can be created, using
+# {#override}, that provides a different value.
+#
+# When binding a {Proc}, the proc is called when the value is looked up, and the result
+# is memoized for subsequent lookups. This provides a lazy mechanism that can be used to
+# delay expensive production of values until they are needed.
+#
+# @api private
+class Puppet::Context
+  require 'puppet/context/trusted_information'
+
+  class UndefinedBindingError < Puppet::Error; end
+  class StackUnderflow < Puppet::Error; end
+
+  class UnknownRollbackMarkError < Puppet::Error; end
+  class DuplicateRollbackMarkError < Puppet::Error; end
+
+  # @api private
+  def initialize(initial_bindings)
+    @table = initial_bindings
+    @description = "root"
+    @id = 0
+    @rollbacks = {}
+    @stack = [[0, nil, nil]]
+  end
+
+  # @api private
+  def push(overrides, description = "")
+    @id += 1
+    @stack.push([@id, @table, @description])
+    @table = @table.merge(overrides || {})
+    @description = description
+  end
+
+  # @api private
+  def pop
+    if @stack[-1][0] == 0
+      raise(StackUnderflow, "Attempted to pop, but already at root of the context stack.")
+    else
+      (_, @table, @description) = @stack.pop
+    end
+  end
+
+  # @api private
+  def lookup(name, &block)
+    if @table.include?(name)
+      value = @table[name]
+      value.is_a?(Proc) ? (@table[name] = value.call) : value
+    elsif block
+      block.call
+    else
+      raise UndefinedBindingError, "no '#{name}' in #{@table.inspect} at top of #{@stack.inspect}"
+    end
+  end
+
+  # @api private
+  def override(bindings, description = "", &block)
+    mark_point = "override over #{@stack[-1][0]}"
+    mark(mark_point)
+    push(bindings, description)
+
+    yield
+  ensure
+    rollback(mark_point)
+  end
+
+  # Mark a place on the context stack to later return to with {rollback}.
+  #
+  # @param name [Object] The identifier for the mark
+  #
+  # @api private
+  def mark(name)
+    if @rollbacks[name].nil?
+      @rollbacks[name] = @stack[-1][0]
+    else
+      raise DuplicateRollbackMarkError, "Mark for '#{name}' already exists"
+    end
+  end
+
+  # Roll back to a mark set by {mark}.
+  #
+  # Rollbacks can only reach a mark accessible via {pop}. If the mark is not on
+  # the current context stack the behavior of rollback is undefined.
+  #
+  # @param name [Object] The identifier for the mark
+  #
+  # @api private
+  def rollback(name)
+    if @rollbacks[name].nil?
+      raise UnknownRollbackMarkError, "Unknown mark '#{name}'"
+    end
+
+    while @stack[-1][0] != @rollbacks[name]
+      pop
+    end
+
+    @rollbacks.delete(name)
+  end
+end