bolt 0.20.0 → 0.20.2

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,197 @@
+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

@@ -0,0 +1,32 @@
+# 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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,153 @@
+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