bolt 0.19.1 → 0.20.0

data/vendored/puppet/lib/puppet/file_system/file_impl.rb

@@ -1,154 +0,0 @@
-# Abstract implementation of the Puppet::FileSystem
-#
-class Puppet::FileSystem::FileImpl
-
-  def pathname(path)
-    path.is_a?(Pathname) ? path : Pathname.new(path)
-  end
-
-  def assert_path(path)
-    return path if path.is_a?(Pathname)
-
-    # Some paths are string, or in the case of WatchedFile, it pretends to be
-    # one by implementing to_str.
-    if path.respond_to?(:to_str)
-      Pathname.new(path)
-    else
-      raise ArgumentError, _("FileSystem implementation expected Pathname, got: '%{klass}'") % { klass: path.class }
-    end
-  end
-
-  def path_string(path)
-    path.to_s
-  end
-
-  def expand_path(path, dir_string = nil)
-    # ensure `nil` values behave like underlying File.expand_path
-    ::File.expand_path(path.nil? ? nil : path_string(path), dir_string)
-  end
-
-  def open(path, mode, options, &block)
-    ::File.open(path, options, mode, &block)
-  end
-
-  def dir(path)
-    path.dirname
-  end
-
-  def basename(path)
-    path.basename.to_s
-  end
-
-  def size(path)
-    path.size
-  end
-
-  def exclusive_create(path, mode, &block)
-    opt = File::CREAT | File::EXCL | File::WRONLY
-    self.open(path, mode, opt, &block)
-  end
-
-  def exclusive_open(path, mode, options = 'r', timeout = 300, &block)
-    wait = 0.001 + (Kernel.rand / 1000)
-    written = false
-    while !written
-      ::File.open(path, options, mode) do |rf|
-        if rf.flock(::File::LOCK_EX|::File::LOCK_NB)
-          yield rf
-          written = true
-        else
-          sleep wait
-          timeout -= wait
-          wait *= 2
-          if timeout < 0
-            raise Timeout::Error, _("Timeout waiting for exclusive lock on %{path}") % { path: @path }
-          end
-        end
-      end
-    end
-  end
-
-  def each_line(path, &block)
-    ::File.open(path) do |f|
-      f.each_line do |line|
-        yield line
-      end
-    end
-  end
-
-  def read(path, opts = {})
-    path.read(opts)
-  end
-
-  def read_preserve_line_endings(path)
-    read(path)
-  end
-
-  def binread(path)
-    raise NotImplementedError
-  end
-
-  def exist?(path)
-    ::File.exist?(path)
-  end
-
-  def directory?(path)
-    ::File.directory?(path)
-  end
-
-  def file?(path)
-    ::File.file?(path)
-  end
-
-  def executable?(path)
-    ::File.executable?(path)
-  end
-
-  def writable?(path)
-    path.writable?
-  end
-
-  def touch(path)
-    ::FileUtils.touch(path)
-  end
-
-  def mkpath(path)
-    path.mkpath
-  end
-
-  def children(path)
-    path.children
-  end
-
-  def symlink(path, dest, options = {})
-    FileUtils.symlink(path, dest, options)
-  end
-
-  def symlink?(path)
-    File.symlink?(path)
-  end
-
-  def readlink(path)
-    File.readlink(path)
-  end
-
-  def unlink(*paths)
-    File.unlink(*paths)
-  end
-
-  def stat(path)
-    File.stat(path)
-  end
-
-  def lstat(path)
-    File.lstat(path)
-  end
-
-  def compare_stream(path, stream)
-    open(path, 0, 'rb') { |this| FileUtils.compare_stream(this, stream) }
-  end
-
-  def chmod(mode, path)
-    FileUtils.chmod(mode, path)
-  end
-end

data/vendored/puppet/lib/puppet/file_system/memory_file.rb

@@ -1,66 +0,0 @@
-# An in-memory file abstraction. Commonly used with Puppet::FileSystem::File#overlay
-# @api private
-class Puppet::FileSystem::MemoryFile
-  attr_reader :path, :children
-
-  def self.a_missing_file(path)
-    new(path, :exist? => false, :executable? => false)
-  end
-
-  def self.a_regular_file_containing(path, content)
-    new(path, :exist? => true, :executable? => false, :content => content)
-  end
-
-  def self.an_executable(path)
-    new(path, :exist? => true, :executable? => true)
-  end
-
-  def self.a_directory(path, children = [])
-    new(path,
-        :exist? => true,
-        :excutable? => true,
-        :directory? => true,
-        :children => children)
-  end
-
-  def initialize(path, properties)
-    @path = path
-    @properties = properties
-    @children = (properties[:children] || []).collect do |child|
-      child.duplicate_as(File.join(@path, child.path))
-    end
-  end
-
-  def directory?; @properties[:directory?]; end
-  def exist?; @properties[:exist?]; end
-  def executable?; @properties[:executable?]; end
-
-  def each_line(&block)
-    handle.each_line(&block)
-  end
-
-  def handle
-    raise Errno::ENOENT unless exist?
-    StringIO.new(@properties[:content] || '')
-  end
-
-  def duplicate_as(other_path)
-    self.class.new(other_path, @properties)
-  end
-
-  def absolute?
-    Pathname.new(path).absolute?
-  end
-
-  def to_path
-    path
-  end
-
-  def to_s
-    to_path
-  end
-
-  def inspect
-    "<Puppet::FileSystem::MemoryFile:#{to_s}>"
-  end
-end

data/vendored/puppet/lib/puppet/file_system/memory_impl.rb

@@ -1,86 +0,0 @@
-class Puppet::FileSystem::MemoryImpl
-  def initialize(*files)
-    @files = files + all_children_of(files)
-  end
-
-  def expand_path(path, dir_string = nil)
-    File.expand_path(path, dir_string)
-  end
-
-  def exist?(path)
-    path.exist?
-  end
-
-  def directory?(path)
-    path.directory?
-  end
-
-  def file?(path)
-    path.file?
-  end
-
-  def executable?(path)
-    path.executable?
-  end
-
-  def children(path)
-    path.children
-  end
-
-  def each_line(path, &block)
-    path.each_line(&block)
-  end
-
-  def pathname(path)
-    find(path) || Puppet::FileSystem::MemoryFile.a_missing_file(path)
-  end
-
-  def basename(path)
-    path.duplicate_as(File.basename(path_string(path)))
-  end
-
-  def path_string(object)
-    object.path
-  end
-
-  def read(path, opts = {})
-    handle = assert_path(path).handle
-    handle.read
-  end
-
-  def read_preserve_line_endings(path)
-    read(path)
-  end
-
-  def open(path, *args, &block)
-    handle = assert_path(path).handle
-    if block_given?
-      yield handle
-    else
-      return handle
-    end
-  end
-
-  def assert_path(path)
-    if path.is_a?(Puppet::FileSystem::MemoryFile)
-      path
-    else
-      find(path) or raise ArgumentError, _("Unable to find registered object for %{path}") % { path: path.inspect }
-    end
-  end
-
-  private
-
-  def find(path)
-    @files.find { |file| file.path == path }
-  end
-
-  def all_children_of(files)
-    children = files.collect(&:children).flatten
-    if children.empty?
-      []
-    else
-      children + all_children_of(children)
-    end
-  end
-end

data/vendored/puppet/lib/puppet/file_system/path_pattern.rb

@@ -1,98 +0,0 @@
-require 'pathname'
-require 'puppet/error'
-
-module Puppet::FileSystem
-  class PathPattern
-    class InvalidPattern < Puppet::Error; end
-
-    TRAVERSAL = /^\.\.$/
-    ABSOLUTE_UNIX = /^\//
-    ABSOLUTE_WINDOWS = /^[a-z]:/i
-    #ABSOLUT_VODKA #notappearinginthisclass
-    CURRENT_DRIVE_RELATIVE_WINDOWS = /^\\/
-
-    def self.relative(pattern)
-      RelativePathPattern.new(pattern)
-    end
-
-    def self.absolute(pattern)
-      AbsolutePathPattern.new(pattern)
-    end
-
-    class << self
-      protected :new
-    end
-
-    # @param prefix [AbsolutePathPattern] An absolute path pattern instance
-    # @return [AbsolutePathPattern] A new AbsolutePathPattern prepended with
-    #   the passed prefix's pattern.
-    def prefix_with(prefix)
-      new_pathname = prefix.pathname + pathname
-      self.class.absolute(new_pathname.to_s)
-    end
-
-    def glob
-      Dir.glob(pathname.to_s)
-    end
-
-    def to_s
-      pathname.to_s
-    end
-
-    protected
-
-    attr_reader :pathname
-
-    private
-
-    def validate
-      @pathname.each_filename do |e|
-        if e =~ TRAVERSAL
-          raise(InvalidPattern, _("PathPatterns cannot be created with directory traversals."))
-        end
-      end
-      case @pathname.to_s
-      when CURRENT_DRIVE_RELATIVE_WINDOWS
-        raise(InvalidPattern, _("A PathPattern cannot be a Windows current drive relative path."))
-      end
-    end
-
-    def initialize(pattern)
-      begin
-        @pathname = Pathname.new(pattern.strip)
-      rescue ArgumentError => error
-        raise InvalidPattern.new(_("PathPatterns cannot be created with a zero byte."), error)
-      end
-      validate
-    end
-  end
-
-  class RelativePathPattern < PathPattern
-    def absolute?
-      false
-    end
-
-    def validate
-      super
-      case @pathname.to_s
-      when ABSOLUTE_WINDOWS
-        raise(InvalidPattern, _("A relative PathPattern cannot be prefixed with a drive."))
-      when ABSOLUTE_UNIX
-        raise(InvalidPattern, _("A relative PathPattern cannot be an absolute path."))
-      end
-    end
-  end
-
-  class AbsolutePathPattern < PathPattern
-    def absolute?
-      true
-    end
-
-    def validate
-      super
-      if @pathname.to_s !~ ABSOLUTE_UNIX and @pathname.to_s !~ ABSOLUTE_WINDOWS
-        raise(InvalidPattern, _("An absolute PathPattern cannot be a relative path."))
-      end
-    end
-  end
-end

data/vendored/puppet/lib/puppet/file_system/posix.rb

@@ -1,46 +0,0 @@
-class Puppet::FileSystem::Posix < Puppet::FileSystem::FileImpl
-  def binread(path)
-    path.binread
-  end
-
-  # Provide an encoding agnostic version of compare_stream
-  #
-  # The FileUtils implementation in Ruby 2.0+ was modified in a manner where
-  # it cannot properly compare File and StringIO instances. To sidestep that
-  # issue this method reimplements the faster 2.0 version that will correctly
-  # compare binary File and StringIO streams.
-  def compare_stream(path, stream)
-    open(path, 0, 'rb') do |this|
-      bsize = stream_blksize(this, stream)
-      sa = "".force_encoding('ASCII-8BIT')
-      sb = "".force_encoding('ASCII-8BIT')
-      begin
-        this.read(bsize, sa)
-        stream.read(bsize, sb)
-        return true if sa.empty? && sb.empty?
-      end while sa == sb
-      false
-    end
-  end
-
-  private
-  def stream_blksize(*streams)
-    streams.each do |s|
-      next unless s.respond_to?(:stat)
-      size = blksize(s.stat)
-      return size if size
-    end
-    default_blksize()
-  end
-
-  def blksize(st)
-    s = st.blksize
-    return nil unless s
-    return nil if s == 0
-    s
-  end
-
-  def default_blksize
-    1024
-  end
-end