bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/settings/array_setting.rb

@@ -1,17 +0,0 @@
-class Puppet::Settings::ArraySetting < Puppet::Settings::BaseSetting
-
-  def type
-    :array
-  end
-
-  def munge(value)
-    case value
-    when String
-      value.split(/\s*,\s*/)
-    when Array
-      value
-    else
-      raise ArgumentError, _("Expected an Array or String, got a %{klass}") % { klass: value.class }
-    end
-  end
-end

data/vendored/puppet/lib/puppet/settings/autosign_setting.rb

@@ -1,22 +0,0 @@
-require 'puppet/settings/base_setting'
-
-# A specialization of the file setting to allow boolean values.
-#
-# The autosign value can be either a boolean or a file path, and if the setting
-# is a file path then it may have a owner/group/mode specified.
-#
-# @api private
-class Puppet::Settings::AutosignSetting < Puppet::Settings::FileSetting
-
-  def munge(value)
-    if ['true', true].include? value
-      true
-    elsif ['false', false, nil].include? value
-      false
-    elsif Puppet::Util.absolute_path?(value)
-      value
-    else
-      raise Puppet::Settings::ValidationError, _("Invalid autosign value %{value}: must be 'true'/'false' or an absolute path") % { value: value }
-    end
-  end
-end

data/vendored/puppet/lib/puppet/settings/base_setting.rb

@@ -1,197 +0,0 @@
-require 'puppet/settings/errors'
-
-# The base setting type
-class Puppet::Settings::BaseSetting
-  attr_accessor :name, :desc, :section, :default, :call_hook
-  attr_reader :short, :deprecated
-
-  def self.available_call_hook_values
-    [:on_define_and_write, :on_initialize_and_write, :on_write_only]
-  end
-
-  def call_hook=(value)
-    if value.nil?
-      #TRANSLATORS ':%{name}', ':call_hook', and ':on_write_only' should not be translated
-      Puppet.warning _("Setting :%{name} :call_hook is nil, defaulting to :on_write_only") % { name: name }
-      value = :on_write_only
-    end
-    unless self.class.available_call_hook_values.include?(value)
-      #TRANSLATORS 'call_hook' is a Puppet option name and should not be translated
-      raise ArgumentError, _("Invalid option %{value} for call_hook") % { value: value }
-    end
-    @call_hook = value
-  end
-
-  def call_hook_on_define?
-    call_hook == :on_define_and_write
-  end
-
-  def call_hook_on_initialize?
-    call_hook == :on_initialize_and_write
-  end
-
-  # get the arguments in getopt format
-  def getopt_args
-    if short
-      [["--#{name}", "-#{short}", GetoptLong::REQUIRED_ARGUMENT]]
-    else
-      [["--#{name}", GetoptLong::REQUIRED_ARGUMENT]]
-    end
-  end
-
-  # get the arguments in OptionParser format
-  def optparse_args
-    if short
-      ["--#{name}", "-#{short}", desc, :REQUIRED]
-    else
-      ["--#{name}", desc, :REQUIRED]
-    end
-  end
-
-  def hook=(block)
-    @has_hook = true
-    meta_def :handle, &block
-  end
-
-  def has_hook?
-    @has_hook
-  end
-
-  # Create the new element.  Pretty much just sets the name.
-  def initialize(args = {})
-    unless @settings = args.delete(:settings)
-      raise ArgumentError.new("You must refer to a settings object")
-    end
-
-    # explicitly set name prior to calling other param= methods to provide meaningful feedback during
-    # other warnings
-    @name = args[:name] if args.include? :name
-
-    #set the default value for call_hook
-    @call_hook = :on_write_only if args[:hook] and not args[:call_hook]
-    @has_hook = false
-
-    if args[:call_hook] and not args[:hook]
-      #TRANSLATORS ':call_hook' and ':hook' are specific setting names and should not be translated
-      raise ArgumentError, _("Cannot reference :call_hook for :%{name} if no :hook is defined") % { name: @name }
-    end
-
-    args.each do |param, value|
-      method = param.to_s + "="
-      unless self.respond_to? method
-        raise ArgumentError, _("%{class_name} (setting '%{setting}') does not accept %{parameter}") %
-            { class_name: self.class, setting: args[:name], parameter: param }
-      end
-
-      self.send(method, value)
-    end
-    unless self.desc
-      raise ArgumentError, _("You must provide a description for the %{class_name} config option") % { class_name: self.name }
-    end
-  end
-
-  def iscreated
-    @iscreated = true
-  end
-
-  def iscreated?
-    @iscreated
-  end
-
-  # short name for the element
-  def short=(value)
-    raise ArgumentError, _("Short names can only be one character.") if value.to_s.length != 1
-    @short = value.to_s
-  end
-
-  def default(check_application_defaults_first = false)
-    if @default.is_a? Proc
-      # Give unit tests a chance to reevaluate the call by removing the instance variable
-      unless instance_variable_defined?(:@evaluated_default)
-        @evaluated_default = @default.call
-      end
-      default_value = @evaluated_default
-    else
-      default_value = @default
-    end
-    return default_value unless check_application_defaults_first
-    return @settings.value(name, :application_defaults, true) || default_value
-  end
-
-  # Convert the object to a config statement.
-  def to_config
-    require 'puppet/util/docs'
-    # Scrub any funky indentation; comment out description.
-    str = Puppet::Util::Docs.scrub(@desc).gsub(/^/, "# ") + "\n"
-
-    # Add in a statement about the default.
-    str << "# The default value is '#{default(true)}'.\n" if default(true)
-
-    # If the value has not been overridden, then print it out commented
-    # and unconverted, so it's clear that that's the default and how it
-    # works.
-    value = @settings.value(self.name)
-
-    if value != @default
-      line = "#{@name} = #{value}"
-    else
-      line = "# #{@name} = #{@default}"
-    end
-
-    str << (line + "\n")
-
-    # Indent
-    str.gsub(/^/, "    ")
-  end
-
-  # @param bypass_interpolation [Boolean] Set this true to skip the
-  #   interpolation step, returning the raw setting value.  Defaults to false.
-  # @return [String] Retrieves the value, or if it's not set, retrieves the default.
-  # @api public
-  def value(bypass_interpolation = false)
-    @settings.value(self.name, nil, bypass_interpolation)
-  end
-
-  # Modify the value when it is first evaluated
-  def munge(value)
-    value
-  end
-
-  # Print the value for the user in a config compatible format
-  def print(value)
-    munge(value)
-  end
-
-  def set_meta(meta)
-    Puppet.notice("#{name} does not support meta data. Ignoring.")
-  end
-
-  def deprecated=(deprecation)
-    unless [:completely, :allowed_on_commandline].include?(deprecation)
-      #TRANSLATORS 'deprecated' is a Puppet setting and ':completely' and ':allowed_on_commandline' are possible values and should not be translated
-      raise ArgumentError, _("Unsupported deprecated value '%{deprecation}'.") % { deprecation: deprecation } +
-          ' ' + _("Supported values for deprecated are ':completely' or ':allowed_on_commandline'")
-    end
-    @deprecated = deprecation
-  end
-
-  def deprecated?
-    !!@deprecated
-  end
-
-  # True if we should raise a deprecation_warning if the setting is submitted
-  # on the commandline or is set in puppet.conf.
-  def completely_deprecated?
-    @deprecated == :completely
-  end
-
-  # True if we should raise a deprecation_warning if the setting is found in
-  # puppet.conf, but not if the user sets it on the commandline
-  def allowed_on_commandline?
-    @deprecated == :allowed_on_commandline
-  end
-
-  def inspect
-    %Q{<#{self.class}:#{self.object_id} @name="#{@name}" @section="#{@section}" @default="#{@default}" @call_hook="#{@call_hook}">}
-  end
-end

data/vendored/puppet/lib/puppet/settings/boolean_setting.rb

@@ -1,32 +0,0 @@
-# A simple boolean.
-class Puppet::Settings::BooleanSetting < Puppet::Settings::BaseSetting
-  # get the arguments in getopt format
-  def getopt_args
-    if short
-      [["--#{name}", "-#{short}", GetoptLong::NO_ARGUMENT], ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
-    else
-      [["--#{name}", GetoptLong::NO_ARGUMENT], ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
-    end
-  end
-
-  def optparse_args
-    if short
-      ["--[no-]#{name}", "-#{short}", desc, :NONE ]
-    else
-      ["--[no-]#{name}", desc, :NONE]
-    end
-  end
-
-  def munge(value)
-    case value
-    when true, "true"; return true
-    when false, "false"; return false
-    else
-      raise Puppet::Settings::ValidationError, _("Invalid value '%{value}' for boolean parameter: %{name}") % { value: value.inspect, name: @name }
-    end
-  end
-
-  def type
-    :boolean
-  end
-end

data/vendored/puppet/lib/puppet/settings/certificate_revocation_setting.rb

@@ -1,21 +0,0 @@
-require 'puppet/settings/base_setting'
-
-class Puppet::Settings::CertificateRevocationSetting < Puppet::Settings::BaseSetting
-
-  def type
-    :certificate_revocation
-  end
-
-  def munge(value)
-    case value
-    when 'chain', 'true', TrueClass
-      :chain
-    when 'leaf'
-      :leaf
-    when 'false', FalseClass, NilClass
-      false
-    else
-      raise Puppet::Settings::ValidationError, _("Invalid certificate revocation value %{value}: must be one of 'true', 'chain', 'leaf', or 'false'") % { value: value }
-    end
-  end
-end

data/vendored/puppet/lib/puppet/settings/config_file.rb

@@ -1,153 +0,0 @@
-require 'puppet/settings/ini_file'
-
-##
-# @api private
-#
-# Parses puppet configuration files
-#
-class Puppet::Settings::ConfigFile
-
-  ##
-  # @param value_converter [Proc] a function that will convert strings into ruby types
-  def initialize(value_converter)
-    @value_converter = value_converter
-  end
-
-  # @param file [String, File] pointer to the file whose text we are parsing
-  # @param text [String] the actual text of the inifile to be parsed
-  # @param allowed_section_names [Array] an optional array of accepted section
-  #   names; if this list is non-empty, sections outside of it will raise an
-  #   error.
-  # @return A Struct with a +sections+ array representing each configuration section
-  def parse_file(file, text, allowed_section_names = [])
-    result = Conf.new
-    if !allowed_section_names.empty?
-      allowed_section_names << 'main' unless allowed_section_names.include?('main')
-    end
-
-    # in Ruby 1.9.3 strings are not UTF-8 by default, so ensure text is treated properly
-    ini = Puppet::Settings::IniFile.parse(StringIO.new(text).set_encoding(Encoding::UTF_8))
-    unique_sections_in(ini, file, allowed_section_names).each do |section_name|
-      section = Section.new(section_name.to_sym)
-      result.with_section(section)
-
-      ini.lines_in(section_name).each do |line|
-        if line.is_a?(Puppet::Settings::IniFile::SettingLine)
-          parse_setting(line, section)
-        elsif line.text !~ /^\s*#|^\s*$/
-          raise Puppet::Settings::ParseError.new(_("Could not match line %{text}") % { text: line.text }, file, line.line_number)
-        end
-      end
-    end
-
-    result
-  end
-
-  Conf = Struct.new(:sections) do
-    def initialize
-      super({})
-    end
-
-    def with_section(section)
-      sections[section.name] = section
-      self
-    end
-  end
-
-  Section = Struct.new(:name, :settings) do
-    def initialize(name)
-      super(name, [])
-    end
-
-    def with_setting(name, value, meta)
-      settings << Setting.new(name, value, meta)
-      self
-    end
-
-    def setting(name)
-      settings.find { |setting| setting.name == name }
-    end
-  end
-
-  Setting = Struct.new(:name, :value, :meta) do
-    def has_metadata?
-      meta != NO_META
-    end
-  end
-
-  Meta = Struct.new(:owner, :group, :mode)
-  NO_META = Meta.new(nil, nil, nil)
-
-private
-
-  def unique_sections_in(ini, file, allowed_section_names)
-    ini.section_lines.collect do |section|
-      if !allowed_section_names.empty? && !allowed_section_names.include?(section.name)
-        error_location_str = Puppet::Util::Errors.error_location(file, section.line_number)
-        message = _("Illegal section '%{name}' in config file at %{error_location}.") %
-            { name: section.name, error_location: error_location_str }
-        #TRANSLATORS 'puppet.conf' is the name of the puppet configuration file and should not be translated.
-        message += ' ' + _("The only valid puppet.conf sections are: [%{allowed_sections_list}].") %
-            { allowed_sections_list: allowed_section_names.join(", ") }
-        message += ' ' + _("Please use the directory environments feature to specify environments.")
-        message += ' ' + _("(See https://docs.puppet.com/puppet/latest/reference/environments.html)")
-        raise(Puppet::Error, message)
-      end
-      section.name
-    end.uniq
-  end
-
-  def parse_setting(setting, section)
-    var = setting.name.intern
-
-    # We don't want to munge modes, because they're specified in octal, so we'll
-    # just leave them as a String, since Puppet handles that case correctly.
-    if var == :mode
-      value = setting.value
-    else
-      value = @value_converter[setting.value]
-    end
-
-    # Check to see if this is a file argument and it has extra options
-    begin
-      if value.is_a?(String) and options = extract_fileinfo(value)
-        section.with_setting(var, options[:value], Meta.new(options[:owner],
-                                                            options[:group],
-                                                            options[:mode]))
-      else
-        section.with_setting(var, value, NO_META)
-      end
-    rescue Puppet::Error => detail
-      raise Puppet::Settings::ParseError.new(detail.message, file, setting.line_number, detail)
-    end
-  end
-
-  def empty_section
-    { :_meta => {} }
-  end
-
-  def extract_fileinfo(string)
-    result = {}
-    value = string.sub(/\{\s*([^}]+)\s*\}/) do
-      params = $1
-      params.split(/\s*,\s*/).each do |str|
-        if str =~ /^\s*(\w+)\s*=\s*([\w]+)\s*$/
-          param, value = $1.intern, $2
-          result[param] = value
-          unless [:owner, :mode, :group].include?(param)
-            raise ArgumentError, _("Invalid file option '%{parameter}'") % { parameter: param }
-          end
-
-          if param == :mode and value !~ /^\d+$/
-            raise ArgumentError, _("File modes must be numbers")
-          end
-        else
-          raise ArgumentError, _("Could not parse '%{string}'") % { string: string }
-        end
-      end
-      ''
-    end
-    result[:value] = value.sub(/\s*$/, '')
-    result
-  end
-end