bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/util/execution_stub.rb

@@ -1,26 +0,0 @@
-module Puppet::Util
-  class ExecutionStub
-    class << self
-      # Set a stub block that Puppet::Util::Execution.execute() should invoke instead
-      # of actually executing commands on the target machine.  Intended
-      # for spec testing.
-      #
-      # The arguments passed to the block are |command, options|, where
-      # command is an array of strings and options is an options hash.
-      def set(&block)
-        @value = block
-      end
-
-      # Uninstall any execution stub, so that calls to
-      # Puppet::Util::Execution.execute() behave normally again.
-      def reset
-        @value = nil
-      end
-
-      # Retrieve the current execution stub, or nil if there is no stub.
-      def current_value
-        @value
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/util/feature.rb

@@ -1,95 +0,0 @@
-require 'puppet'
-
-class Puppet::Util::Feature
-  attr_reader :path
-
-  # Create a new feature test.  You have to pass the feature name,
-  # and it must be unique.  You can either provide a block that
-  # will get executed immediately to determine if the feature
-  # is present, or you can pass an option to determine it.
-  # Currently, the only supported option is 'libs' (must be
-  # passed as a symbol), which will make sure that each lib loads
-  # successfully.
-  def add(name, options = {})
-    method = name.to_s + "?"
-    @results.delete(name)
-
-    if block_given?
-      begin
-        result = yield
-      rescue StandardError,ScriptError => detail
-        warn _("Failed to load feature test for %{name}: %{detail}") % { name: name, detail: detail }
-        result = false
-      end
-      @results[name] = result
-    end
-
-    meta_def(method) do
-      # we return a cached result if:
-      #  * if a block is given (and we just evaluated it above)
-      #  * if we already have a positive result
-      #  * if we've tested this feature before and it failed, but we're
-      #    configured to always cache
-      if block_given?     ||
-          @results[name]  ||
-          (@results.has_key?(name) && (!Puppet[:always_retry_plugins]))
-        @results[name]
-      else
-        @results[name] = test(name, options)
-        @results[name]
-      end
-    end
-  end
-
-  # Create a new feature collection.
-  def initialize(path)
-    @path = path
-    @results = {}
-    @loader = Puppet::Util::Autoload.new(self, @path)
-  end
-
-  def load
-    @loader.loadall
-  end
-
-  def method_missing(method, *args)
-    return super unless method.to_s =~ /\?$/
-
-    feature = method.to_s.sub(/\?$/, '')
-    @loader.load(feature)
-
-    respond_to?(method) && self.send(method)
-  end
-
-  # Actually test whether the feature is present.  We only want to test when
-  # someone asks for the feature, so we don't unnecessarily load
-  # files.
-  def test(name, options)
-    return true unless ary = options[:libs]
-    ary = [ary] unless ary.is_a?(Array)
-
-    ary.each do |lib|
-      return false unless load_library(lib, name)
-    end
-
-    # We loaded all of the required libraries
-    true
-  end
-
-  private
-
-  def load_library(lib, name)
-    raise ArgumentError, _("Libraries must be passed as strings not %{klass}") % { klass: lib.class } unless lib.is_a?(String)
-
-    @rubygems ||= Puppet::Util::RubyGems::Source.new
-    @rubygems.clear_paths
-
-    begin
-      require lib
-    rescue ScriptError => detail
-      Puppet.debug _("Failed to load library '%{lib}' for feature '%{name}': %{detail}") % { lib: lib, name: name, detail: detail }
-      return false
-    end
-    true
-  end
-end

data/vendored/puppet/lib/puppet/util/file_watcher.rb

@@ -1,28 +0,0 @@
-class Puppet::Util::FileWatcher
-  include Enumerable
-
-  def each(&blk)
-    @files.keys.each(&blk)
-  end
-
-  def initialize
-    @files = {}
-  end
-
-  def changed?
-    @files.values.any?(&:changed?)
-  end
-
-  def watch(filename)
-    return if watching?(filename)
-    @files[filename] = Puppet::Util::WatchedFile.new(filename)
-  end
-
-  def watching?(filename)
-    @files.has_key?(filename)
-  end
-
-  def clear
-    @files.clear
-  end
-end

data/vendored/puppet/lib/puppet/util/fileparsing.rb

@@ -1,375 +0,0 @@
-# A mini-language for parsing files.  This is only used file the ParsedFile
-# provider, but it makes more sense to split it out so it's easy to maintain
-# in one place.
-#
-# You can use this module to create simple parser/generator classes.  For instance,
-# the following parser should go most of the way to parsing /etc/passwd:
-#
-#   class Parser
-#       include Puppet::Util::FileParsing
-#       record_line :user, :fields => %w{name password uid gid gecos home shell},
-#           :separator => ":"
-#   end
-#
-# You would use it like this:
-#
-#   parser = Parser.new
-#   lines = parser.parse(File.read("/etc/passwd"))
-#
-#   lines.each do |type, hash| # type will always be :user, since we only have one
-#       p hash
-#   end
-#
-# Each line in this case would be a hash, with each field set appropriately.
-# You could then call 'parser.to_line(hash)' on any of those hashes to generate
-# the text line again.
-
-require 'puppet/util/methodhelper'
-
-module Puppet::Util::FileParsing
-  include Puppet::Util
-  attr_writer :line_separator, :trailing_separator
-
-  class FileRecord
-    include Puppet::Util
-    include Puppet::Util::MethodHelper
-    attr_accessor :absent, :joiner, :rts, :separator, :rollup, :name, :match, :block_eval
-
-    attr_reader :fields, :optional, :type
-
-    INVALID_FIELDS = [:record_type, :target, :on_disk]
-
-    # Customize this so we can do a bit of validation.
-    def fields=(fields)
-      @fields = fields.collect do |field|
-        r = field.intern
-        raise ArgumentError.new(_("Cannot have fields named %{name}") % { name: r }) if INVALID_FIELDS.include?(r)
-        r
-      end
-    end
-
-    def initialize(type, options = {}, &block)
-      @type = type.intern
-      raise ArgumentError, _("Invalid record type %{record_type}") % { record_type: @type } unless [:record, :text].include?(@type)
-
-      set_options(options)
-
-      if self.type == :record
-        # Now set defaults.
-        self.absent ||= ""
-        self.separator ||= /\s+/
-        self.joiner ||= " "
-        self.optional ||= []
-        @rollup = true unless defined?(@rollup)
-      end
-
-      if block_given?
-        @block_eval ||= :process
-
-        # Allow the developer to specify that a block should be instance-eval'ed.
-        if @block_eval == :instance
-          instance_eval(&block)
-        else
-          meta_def(@block_eval, &block)
-        end
-      end
-    end
-
-    # Convert a record into a line by joining the fields together appropriately.
-    # This is pulled into a separate method so it can be called by the hooks.
-    def join(details)
-      joinchar = self.joiner
-
-      fields.collect { |field|
-        # If the field is marked absent, use the appropriate replacement
-        if details[field] == :absent or details[field] == [:absent] or details[field].nil?
-          if self.optional.include?(field)
-            self.absent
-          else
-            raise ArgumentError, _("Field '%{field}' is required") % { field: field }
-          end
-        else
-          details[field].to_s
-        end
-      }.reject { |c| c.nil?}.join(joinchar)
-    end
-
-    # Customize this so we can do a bit of validation.
-    def optional=(optional)
-      @optional = optional.collect do |field|
-        field.intern
-      end
-    end
-
-    # Create a hook that modifies the hash resulting from parsing.
-    def post_parse=(block)
-      meta_def(:post_parse, &block)
-    end
-
-    # Create a hook that modifies the hash just prior to generation.
-    def pre_gen=(block)
-      meta_def(:pre_gen, &block)
-    end
-
-    # Are we a text type?
-    def text?
-      type == :text
-    end
-
-    def to_line=(block)
-      meta_def(:to_line, &block)
-    end
-  end
-
-  # Clear all existing record definitions.  Only used for testing.
-  def clear_records
-    @record_types.clear
-    @record_order.clear
-  end
-
-  def fields(type)
-    if record = record_type(type)
-      record.fields.dup
-    else
-      nil
-    end
-  end
-
-  # Try to match a specific text line.
-  def handle_text_line(line, record)
-    line =~ record.match ? {:record_type => record.name, :line => line} : nil
-  end
-
-  # Try to match a record.
-  #
-  # @param [String] line The line to be parsed
-  # @param [Puppet::Util::FileType] record The filetype to use for parsing
-  #
-  # @return [Hash<Symbol, Object>] The parsed elements of the line
-  def handle_record_line(line, record)
-    ret = nil
-    if record.respond_to?(:process)
-      if ret = record.send(:process, line.dup)
-        unless ret.is_a?(Hash)
-          raise Puppet::DevError, _("Process record type %{record_name} returned non-hash") % { record_name: record.name }
-        end
-      else
-        return nil
-      end
-    elsif regex = record.match
-      # In this case, we try to match the whole line and then use the
-      # match captures to get our fields.
-      if match = regex.match(line)
-        ret = {}
-        record.fields.zip(match.captures).each do |field, value|
-          if value == record.absent
-            ret[field] = :absent
-          else
-            ret[field] = value
-          end
-        end
-      else
-        nil
-      end
-    else
-      ret = {}
-      sep = record.separator
-
-      # String "helpfully" replaces ' ' with /\s+/ in splitting, so we
-      # have to work around it.
-      if sep == " "
-        sep = / /
-      end
-      line_fields = line.split(sep)
-      record.fields.each do |param|
-        value = line_fields.shift
-        if value and value != record.absent
-          ret[param] = value
-        else
-          ret[param] = :absent
-        end
-      end
-
-      if record.rollup and ! line_fields.empty?
-        last_field = record.fields[-1]
-        val = ([ret[last_field]] + line_fields).join(record.joiner)
-        ret[last_field] = val
-      end
-    end
-
-    if ret
-      ret[:record_type] = record.name
-      return ret
-    else
-      return nil
-    end
-  end
-
-  def line_separator
-    @line_separator ||= "\n"
-
-    @line_separator
-  end
-
-  # Split text into separate lines using the record separator.
-  def lines(text)
-    # NOTE: We do not have to remove trailing separators because split will ignore
-    # them by default (unless you pass -1 as a second parameter)
-    text.split(self.line_separator)
-  end
-
-  # Split a bunch of text into lines and then parse them individually.
-  def parse(text)
-    count = 1
-    lines(text).collect do |line|
-      count += 1
-      if val = parse_line(line)
-        val
-      else
-        error = Puppet::ResourceError.new(_("Could not parse line %{line}") % { line: line.inspect })
-        error.line = count
-        raise error
-      end
-    end
-  end
-
-  # Handle parsing a single line.
-  def parse_line(line)
-    raise Puppet::DevError, _("No record types defined; cannot parse lines") unless records?
-
-    @record_order.each do |record|
-      # These are basically either text or record lines.
-      method = "handle_#{record.type}_line"
-      if respond_to?(method)
-        if result = send(method, line, record)
-          record.send(:post_parse, result) if record.respond_to?(:post_parse)
-          return result
-        end
-      else
-        raise Puppet::DevError, _("Somehow got invalid line type %{record_type}") % { record_type: record.type }
-      end
-    end
-
-    nil
-  end
-
-  # Define a new type of record.  These lines get split into hashes.  Valid
-  # options are:
-  # * <tt>:absent</tt>: What to use as value within a line, when a field is
-  #   absent.  Note that in the record object, the literal :absent symbol is
-  #   used, and not this value.  Defaults to "".
-  # * <tt>:fields</tt>: The list of fields, as an array.  By default, all
-  #   fields are considered required.
-  # * <tt>:joiner</tt>: How to join fields together.  Defaults to '\t'.
-  # * <tt>:optional</tt>: Which fields are optional.  If these are missing,
-  #   you'll just get the 'absent' value instead of an ArgumentError.
-  # * <tt>:rts</tt>: Whether to remove trailing whitespace.  Defaults to false.
-  #   If true, whitespace will be removed; if a regex, then whatever matches
-  #   the regex will be removed.
-  # * <tt>:separator</tt>: The record separator.  Defaults to /\s+/.
-  def record_line(name, options, &block)
-    raise ArgumentError, _("Must include a list of fields") unless options.include?(:fields)
-
-    record = FileRecord.new(:record, options, &block)
-    record.name = name.intern
-
-    new_line_type(record)
-  end
-
-  # Are there any record types defined?
-  def records?
-    defined?(@record_types) and ! @record_types.empty?
-  end
-
-  # Define a new type of text record.
-  def text_line(name, options, &block)
-    raise ArgumentError, _("You must provide a :match regex for text lines") unless options.include?(:match)
-
-    record = FileRecord.new(:text, options, &block)
-    record.name = name.intern
-
-    new_line_type(record)
-  end
-
-  # Generate a file from a bunch of hash records.
-  def to_file(records)
-    text = records.collect { |record| to_line(record) }.join(line_separator)
-
-    text += line_separator if trailing_separator
-
-    text
-  end
-
-  # Convert our parsed record into a text record.
-  def to_line(details)
-    unless record = record_type(details[:record_type])
-      raise ArgumentError, _("Invalid record type %{record_type}") % { record_type: details[:record_type].inspect }
-    end
-
-    if record.respond_to?(:pre_gen)
-      details = details.dup
-      record.send(:pre_gen, details)
-    end
-
-    case record.type
-    when :text; return details[:line]
-    else
-      return record.to_line(details) if record.respond_to?(:to_line)
-
-      line = record.join(details)
-
-      if regex = record.rts
-        # If they say true, then use whitespace; else, use their regex.
-        if regex == true
-          regex = /\s+$/
-        end
-        return line.sub(regex,'')
-      else
-        return line
-      end
-    end
-  end
-
-  # Whether to add a trailing separator to the file.  Defaults to true
-  def trailing_separator
-    if defined?(@trailing_separator)
-      return @trailing_separator
-    else
-      return true
-    end
-  end
-
-  def valid_attr?(type, attr)
-    type = type.intern
-    if record = record_type(type) and record.fields.include?(attr.intern)
-      return true
-    else
-      if attr.intern == :ensure
-        return true
-      else
-        false
-      end
-    end
-  end
-
-  private
-
-  # Define a new type of record.
-  def new_line_type(record)
-    @record_types ||= {}
-    @record_order ||= []
-
-    raise ArgumentError, _("Line type %{name} is already defined") % { name: record.name } if @record_types.include?(record.name)
-
-    @record_types[record.name] = record
-    @record_order << record
-
-    record
-  end
-
-  # Retrieve the record object.
-  def record_type(type)
-    @record_types[type.intern]
-  end
-end
-