bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/parameter/boolean.rb

@@ -1,15 +0,0 @@
-require 'puppet/coercion'
-
-# This specialized {Puppet::Parameter} handles Boolean options, accepting lots
-# of strings and symbols for both truth and falsehood.
-#
-class Puppet::Parameter::Boolean < Puppet::Parameter
-  def unsafe_munge(value)
-    Puppet::Coercion.boolean(value)
-  end
-
-  def self.initvars
-    super
-    @value_collection.newvalues(*Puppet::Coercion.boolean_values)
-  end
-end

data/vendored/puppet/lib/puppet/parameter/package_options.rb

@@ -1,31 +0,0 @@
-require 'puppet/parameter'
-
-# This specialized {Puppet::Parameter} handles munging of package options.
-# Package options are passed as an array of key value pairs. Special munging is
-# required as the keys and values needs to be quoted in a safe way.
-#
-class Puppet::Parameter::PackageOptions < Puppet::Parameter
-  def unsafe_munge(values)
-    values = [values] unless values.is_a? Array
-
-    values.collect do |val|
-      case val
-      when Hash
-        safe_hash = {}
-        val.each_pair do |k, v|
-          safe_hash[quote(k)] = quote(v)
-        end
-        safe_hash
-      when String
-        quote(val)
-      else
-        fail(_("Expected either a string or hash of options"))
-      end
-    end
-  end
-
-  # @api private
-  def quote(value)
-    value.include?(' ') ? %Q["#{value.gsub(/"/, '\"')}"] : value
-  end
-end

data/vendored/puppet/lib/puppet/parameter/path.rb

@@ -1,57 +0,0 @@
-require 'puppet/parameter'
-
-# This specialized {Puppet::Parameter} handles validation and munging of paths.
-# By default, a single path is accepted, and by calling {accept_arrays} it is possible to
-# allow an array of paths.
-#
-class Puppet::Parameter::Path < Puppet::Parameter
-  # Specifies whether multiple paths are accepted or not.
-  # @dsl type
-  #
-  def self.accept_arrays(bool = true)
-    @accept_arrays = !!bool
-  end
-  def self.arrays?
-    @accept_arrays
-  end
-
-  # Performs validation of the given paths.
-  # If the concrete parameter defines a validation method, it may call this method to perform
-  # path validation.
-  # @raise [Puppet::Error] if this property is configured for single paths and an array is given
-  # @raise [Puppet::Error] if a path is not an absolute path
-  # @return [Array<String>] the given paths
-  #
-  def validate_path(paths)
-    if paths.is_a?(Array) and ! self.class.arrays? then
-      fail _("%{name} only accepts a single path, not an array of paths") % { name: name }
-    end
-
-    fail(_("%{name} must be a fully qualified path") % { name: name }) unless Array(paths).all? {|path| absolute_path?(path)}
-
-    paths
-  end
-
-  # This is the default implementation of the `validate` method.
-  # It will be overridden if the validate option is used when defining the parameter.
-  # @return [void]
-  #
-  def unsafe_validate(paths)
-    validate_path(paths)
-  end
-
-  # This is the default implementation  of `munge`.
-  # If the concrete parameter defines a `munge` method, this default implementation will be overridden.
-  # This default implementation does not perform any munging, it just checks the one/many paths
-  # constraints. A derived implementation can perform this check as:
-  # `paths.is_a?(Array) and ! self.class.arrays?` and raise a {Puppet::Error}.
-  # @param paths [String, Array<String>] one of multiple paths
-  # @return [String, Array<String>] the given paths
-  # @raise [Puppet::Error] if the given paths does not comply with the on/many paths rule.
-  def unsafe_munge(paths)
-    if paths.is_a?(Array) and ! self.class.arrays? then
-      fail _("%{name} only accepts a single path, not an array of paths") % { name: name }
-    end
-    paths
-  end
-end

data/vendored/puppet/lib/puppet/parameter/value.rb

@@ -1,91 +0,0 @@
-require 'puppet/parameter/value_collection'
-
-# Describes an acceptable value for a parameter or property.
-# An acceptable value is either specified as a literal value or a regular expression.
-# @note this class should be used via the api methods in {Puppet::Parameter} and {Puppet::Property}
-# @api private
-#
-class Puppet::Parameter::Value
-  attr_reader :name, :options, :event
-  attr_accessor :block, :method, :required_features, :invalidate_refreshes
-
-  # Adds an alias for this value.
-  # Makes the given _name_ be an alias for this acceptable value.
-  # @param name [Symbol] the additional alias this value should be known as
-  # @api private
-  #
-  def alias(name)
-    @aliases << convert(name)
-  end
-
-  # @return [Array<Symbol>] Returns all aliases (or an empty array).
-  # @api private
-  #
-  def aliases
-    @aliases.dup
-  end
-
-  # Stores the event that our value generates, if it does so.
-  # @api private
-  #
-  def event=(value)
-    @event = convert(value)
-  end
-
-  # Initializes the instance with a literal accepted value, or a regular expression.
-  # If anything else is passed, it is turned into a String, and then made into a Symbol.
-  # @param name [Symbol, Regexp, Object] the value to accept, Symbol, a regular expression, or object to convert.
-  # @api private
-  #
-  def initialize(name)
-    if name.is_a?(Regexp)
-      @name = name
-    else
-      # Convert to a string and then a symbol, so things like true/false
-      # still show up as symbols.
-      @name = convert(name)
-    end
-
-    @aliases = []
-  end
-
-  # Checks if the given value matches the acceptance rules (literal value, regular expression, or one
-  # of the aliases.
-  # @api private
-  #
-  def match?(value)
-    if regex?
-      return true if name =~ value.to_s
-    else
-      return(name == convert(value) ? true : @aliases.include?(convert(value)))
-    end
-  end
-
-  # @return [Boolean] whether the accepted value is a regular expression or not.
-  # @api private
-  #
-  def regex?
-    @name.is_a?(Regexp)
-  end
-
-  private
-
-  # A standard way of converting all of our values, so we're always
-  # comparing apples to apples.
-  # @api private
-  #
-  def convert(value)
-    case value
-    when Symbol, ''             # can't intern an empty string
-      value
-    when String
-      value.intern
-    when true
-      :true
-    when false
-      :false
-    else
-      value.to_s.intern
-    end
-  end
-end

data/vendored/puppet/lib/puppet/parameter/value_collection.rb

@@ -1,212 +0,0 @@
-require 'puppet/parameter/value'
-
-# A collection of values and regular expressions, used for specifying allowed values
-# in a given parameter.
-# @note This class is considered part of the internal implementation of {Puppet::Parameter}, and
-#   {Puppet::Property} and the functionality provided by this class should be used via their interfaces.
-# @comment This class probably have several problems when trying to use it with a combination of
-#   regular expressions and aliases as it finds an acceptable value holder vi "name" which may be
-#   a regular expression...
-#
-# @api private
-#
-class Puppet::Parameter::ValueCollection
-
-  # Aliases the given existing _other_ value with the additional given _name_.
-  # @return [void]
-  # @api private
-  #
-  def aliasvalue(name, other)
-    other = other.to_sym
-    unless value = match?(other)
-      raise Puppet::DevError, _("Cannot alias nonexistent value %{value}") % { value: other }
-    end
-
-    value.alias(name)
-  end
-
-  # Returns a doc string (enumerating the acceptable values) for all of the values in this parameter/property.
-  # @return [String] a documentation string.
-  # @api private
-  #
-  def doc
-    unless defined?(@doc)
-      @doc = ""
-      unless values.empty?
-        @doc << "Valid values are "
-        @doc << @strings.collect do |value|
-          if aliases = value.aliases and ! aliases.empty?
-            "`#{value.name}` (also called `#{aliases.join(", ")}`)"
-          else
-            "`#{value.name}`"
-          end
-        end.join(", ") << ". "
-      end
-
-      unless regexes.empty?
-        @doc << "Values can match `#{regexes.join("`, `")}`."
-      end
-    end
-
-    @doc
-  end
-
-  # @return [Boolean] Returns whether the set of allowed values is empty or not.
-  # @api private
-  #
-  def empty?
-    @values.empty?
-  end
-
-  # @api private
-  #
-  def initialize
-    # We often look values up by name, so a hash makes more sense.
-    @values = {}
-
-    # However, we want to retain the ability to match values in order,
-    # but we always prefer directly equality (i.e., strings) over regex matches.
-    @regexes = []
-    @strings = []
-  end
-
-  # Checks if the given value is acceptable (matches one of the literal values or patterns) and returns
-  # the "matcher" that matched.
-  # Literal string matchers are tested first, if both a literal and a regexp match would match, the literal
-  # match wins.
-  #
-  # @param test_value [Object] the value to test if it complies with the configured rules
-  # @return [Puppet::Parameter::Value, nil] The instance of Puppet::Parameter::Value that matched the given value, or nil if there was no match.
-  # @api private
-  #
-  def match?(test_value)
-    # First look for normal values
-    if value = @strings.find { |v| v.match?(test_value) }
-      return value
-    end
-
-    # Then look for a regex match
-    @regexes.find { |v| v.match?(test_value) }
-  end
-
-  # Munges the value if it is valid, else produces the same value.
-  # @param value [Object] the value to munge
-  # @return [Object] the munged value, or the given value
-  # @todo This method does not seem to do any munging. It just returns the value if it matches the
-  #   regexp, or the (most likely Symbolic) allowed value if it matches (which is more of a replacement
-  #   of one instance with an equal one. Is the intent that this method should be specialized?
-  # @api private
-  #
-  def munge(value)
-    return value if empty?
-
-    if instance = match?(value)
-      if instance.regex?
-        return value
-      else
-        return instance.name
-      end
-    else
-      return value
-    end
-  end
-
-  # Defines a new valid value for a {Puppet::Property}.
-  # A valid value is specified as a literal (typically a Symbol), but can also be
-  # specified with a regexp.
-  #
-  # @param name [Symbol, Regexp] a valid literal value, or a regexp that matches a value
-  # @param options [Hash] a hash with options
-  # @option options [Symbol] :event The event that should be emitted when this value is set.
-  # @todo Option :event original comment says "event should be returned...", is "returned" the correct word
-  #   to use?
- # @option options [Symbol] :invalidate_refreshes True if a change on this property should invalidate and
-  #   remove any scheduled refreshes (from notify or subscribe) targeted at the same resource. For example, if
-  #   a change in this property takes into account any changes that a scheduled refresh would have performed,
-  #   then the scheduled refresh would be deleted.
-  # @option options [Object] _any_ Any other option is treated as a call to a setter having the given
-  #   option name (e.g. `:required_features` calls `required_features=` with the option's value as an
-  #   argument).
-  # @api private
-  #
-  def newvalue(name, options = {}, &block)
-    call_opt = options[:call]
-    unless call_opt.nil?
-      devfail "Cannot use obsolete :call value '#{call_opt}' for property '#{self.class.name}'" unless call_opt == :none || call_opt == :instead
-      #TRANSLATORS ':call' is a property and should not be translated
-      message = _("Property option :call is deprecated and no longer used.")
-      message += ' ' + _("Please remove it.")
-      Puppet.deprecation_warning(message)
-      options = options.reject { |k,v| k == :call }
-    end
-
-    value = Puppet::Parameter::Value.new(name)
-    @values[value.name] = value
-    if value.regex?
-      @regexes << value
-    else
-      @strings << value
-    end
-
-    options.each { |opt, arg| value.send(opt.to_s + "=", arg) }
-    if block_given?
-      devfail "Cannot use :call value ':none' in combination with a block for property '#{self.class.name}'" if call_opt == :none
-      value.block = block
-      value.method ||= "set_#{value.name}" if !value.regex?
-    else
-      devfail "Cannot use :call value ':instead' without a block for property '#{self.class.name}'" if call_opt == :instead
-    end
-    value
-  end
-
-  # Defines one or more valid values (literal or regexp) for a parameter or property.
-  # @return [void]
-  # @dsl type
-  # @api private
-  #
-  def newvalues(*names)
-    names.each { |name| newvalue(name) }
-  end
-
-  # @return [Array<String>] An array of the regular expressions in string form, configured as matching valid values.
-  # @api private
-  #
-  def regexes
-    @regexes.collect { |r| r.name.inspect }
-  end
-
-  # Validates the given value against the set of valid literal values and regular expressions.
-  # @raise [ArgumentError] if the value is not accepted
-  # @return [void]
-  # @api private
-  #
-  def validate(value)
-    return if empty?
-
-    unless @values.detect {|name, v| v.match?(value)}
-      str = _("Invalid value %{value}.") % { value: value.inspect }
-      str += " " + _("Valid values are %{value_list}.") % { value_list: values.join(", ") } unless values.empty?
-      str += " " + _("Valid values match %{pattern}.") % { pattern: regexes.join(", ") } unless regexes.empty?
-      raise ArgumentError, str
-    end
-  end
-
-  # Returns a valid value matcher (a literal or regular expression)
-  # @todo This looks odd, asking for an instance that matches a symbol, or an instance that has
-  #   a regexp. What is the intention here? Marking as api private...
-  #
-  # @return [Puppet::Parameter::Value] a valid value matcher
-  # @api private
-  #
-  def value(name)
-    @values[name]
-  end
-
-  # @return [Array<Symbol>] Returns a list of valid literal values.
-  # @see regexes
-  # @api private
-  #
-  def values
-    @strings.collect { |s| s.name }
-  end
-end

data/vendored/puppet/lib/puppet/parser.rb

@@ -1,20 +0,0 @@
-# is only needed to create the name space
-module Puppet::Parser; end
-
-require 'puppet/parser/ast'
-require 'puppet/parser/abstract_compiler'
-require 'puppet/parser/compiler'
-require 'puppet/parser/compiler/catalog_validator'
-require 'puppet/resource/type_collection'
-
-require 'puppet/parser/functions'
-require 'puppet/parser/files'
-require 'puppet/parser/relationship'
-
-require 'puppet/resource/type'
-require 'monitor'
-
-Dir[File.dirname(__FILE__) + '/parser/compiler/catalog_validator/*.rb'].each { |f| require f }
-
-# PUP-3274 This should probably go someplace else
-class Puppet::LexError < RuntimeError; end

data/vendored/puppet/lib/puppet/parser/abstract_compiler.rb

@@ -1,36 +0,0 @@
-
-module Puppet::Parser::AbstractCompiler
-
-  # Returns the catalog for a compilation. Must return a Puppet::Resource::Catalog or fail with an 
-  # error if the specific compiler does not support catalog operations.
-  #
-  def catalog
-    raise Puppet::DevError("Class '#{self.class}' should have implemented 'catalog'")
-  end
-
-  # Returns the environment for the compilation
-  #
-  def environment
-    raise Puppet::DevError("Class '#{self.class}' should have implemented 'environment'")
-  end
-
-  # Produces a new scope
-  # This method is here if there are functions/logic that will call this for some other purpose than to create
-  # a named scope for a class. It may not have to be here. (TODO)
-  #
-  def newscope(scope, options)
-    raise Puppet::DevError("Class '#{self.class}' should have implemented 'newscope'")
-  end
-
-  # Returns a hash of all externally referenceable qualified variables
-  #
-  def qualified_variables
-    raise Puppet::DevError("Class '#{self.class}' should have implemented 'qualified_variables'")
-  end
-
-  # Returns the top scope instance
-  def topscope
-    raise Puppet::DevError("Class '#{self.class}' should have implemented 'topscope'")
-  end
-
-end