vagrant-unbundled 2.0.3.0 → 2.0.4.0

data/vendor/bundle/ruby/2.5.0/gems/win32-file-0.8.1/lib/win32/file.rb

@@ -0,0 +1,585 @@
+require_relative 'file/constants'
+require_relative 'file/structs'
+require_relative 'file/functions'
+require 'ffi/win32/extensions'
+require 'win32/file/stat'
+
+class File
+  include Windows::File::Constants
+  include Windows::File::Structs
+  extend Windows::File::Functions
+
+  # The version of the win32-file library
+  WIN32_FILE_VERSION = '0.8.1'
+
+  class << self
+    alias_method :join_orig, :join
+    alias_method :realpath_orig, :realpath
+    alias_method :realdirpath_orig, :realdirpath
+
+    remove_method :atime, :basename, :blockdev?, :chardev?, :ctime, :dirname
+    remove_method :directory?, :executable?, :executable_real?, :file?
+    remove_method :ftype, :grpowned?, :join, :lstat, :owned?, :pipe?, :socket?
+    remove_method :readable?, :readable_real?, :readlink, :realpath
+    remove_method :realdirpath
+    remove_method :split, :stat
+    remove_method :symlink
+    remove_method :symlink?
+    remove_method :world_readable?, :world_writable?
+    remove_method :writable?, :writable_real?
+  end
+
+  ## Path methods
+
+  # Returns the last component of the filename given in +filename+.  If
+  # +suffix+ is given and present at the end of +filename+, it is removed.
+  # Any extension can be removed by giving an extension of ".*".
+  #
+  # This was reimplemented because the current version does not handle UNC
+  # paths properly, i.e. it should not return anything less than the root.
+  # In most other respects it is identical to the current implementation,
+  # except that it does not strip the drive letter on a root path.
+  #
+  # Unlike MRI, this version will convert all forward slashes to
+  # backslashes automatically.
+  #
+  # Examples:
+  #
+  #    File.basename("C:\\foo\\bar.txt")         -> "bar.txt"
+  #    File.basename("C:\\foo\\bar.txt", ".txt") -> "bar"
+  #    File.basename("\\\\foo\\bar")             -> "\\\\foo\\bar"
+  #
+  def self.basename(file, suffix = nil)
+    file = string_check(file)
+    suffix = string_check(suffix) if suffix
+
+    return file if file.empty? # Return an empty path as-is.
+
+    encoding = file.encoding
+    wfile = file.wincode
+
+    # Return a root path as-is.
+    if PathIsRootW(wfile)
+      return file.tr(File::SEPARATOR, File::ALT_SEPARATOR)
+    end
+
+    ptr = FFI::MemoryPointer.from_string(wfile)
+
+    PathStripPathW(ptr) # Gives us the basename
+
+    if suffix
+      if suffix == '.*'
+        PathRemoveExtensionW(ptr)
+      else
+        ext = PathFindExtensionW(ptr).read_string(suffix.length * 2).wstrip
+
+        if ext == suffix
+          PathRemoveExtensionW(ptr)
+        end
+      end
+    end
+
+    wfile = ptr.read_bytes(wfile.size * 2).split("\000\000").first.tr(0.chr, '')
+    file = wfile.encode(encoding)[/^[^\0]*/]
+    file.sub!(/\\+\z/, '') # Trim trailing slashes
+
+    ptr.free
+
+    file
+  end
+
+  # Returns all components of the filename given in +filename+ except the
+  # last one.
+  #
+  # This was reimplemented because the current version does not handle UNC
+  # paths properly, i.e. it should not return anything less than the root.
+  # In all other respects it is identical to the current implementation.
+  #
+  # Also, this method will convert all forward slashes to backslashes.
+  #
+  # Examples:
+  #
+  #    File.dirname("C:\\foo\\bar\\baz.txt") -> "C:\\foo\\bar"
+  #    File.dirname("\\\\foo\\bar")          -> "\\\\foo\\bar"
+  #
+  def self.dirname(file)
+    file = string_check(file)
+
+    # Short circuit for empty paths
+    return '.' if file.empty?
+
+    # Store original encoding, restore it later
+    encoding = file.encoding
+
+    # Convert to UTF-16LE
+    wfile = file.wincode
+
+    # Return a root path as-is.
+    if PathIsRootW(wfile)
+      return file.tr(File::SEPARATOR, File::ALT_SEPARATOR)
+    end
+
+    ptr = FFI::MemoryPointer.from_string(wfile)
+
+    # Remove trailing slashes if present
+    while result = PathRemoveBackslashW(ptr)
+      break unless result.empty?
+    end
+
+    # Remove trailing file name if present
+    unless PathRemoveFileSpecW(ptr)
+      raise SystemCallError.new("PathRemoveFileSpec", FFI.errno)
+    end
+
+    wfile = ptr.read_bytes(wfile.size * 2).split("\000\000").first
+
+    # Empty paths, short relative paths
+    if wfile.nil? or wfile.empty?
+      return '.'
+    end
+
+    # Return to original encoding
+    file = wfile.tr(0.chr, '').encode(encoding)
+
+    ptr.free
+
+    file
+  end
+
+  # Join path string components together into a single string.
+  #
+  # This method was reimplemented so that it automatically converts
+  # forward slashes to backslashes. It is otherwise identical to
+  # the core File.join method.
+  #
+  # Examples:
+  #
+  #   File.join("C:", "foo", "bar") # => C:\foo\bar
+  #   File.join("foo", "bar")       # => foo\bar
+  #
+  def self.join(*args)
+    return join_orig(*args).tr("/", "\\")
+  end
+
+  # Splits the given string into a directory and a file component and
+  # returns them in a two element array. This was reimplemented because
+  # the current version does not handle UNC paths properly.
+  #
+  def self.split(file)
+    file = string_check(file)
+    array = []
+
+    if file.empty? || PathIsRootW(file.wincode)
+      array.push(file, '')
+    else
+      array.push(File.dirname(file), File.basename(file))
+    end
+
+    array
+  end
+
+  # Returns +path+ in long format. For example, if 'SOMEFI~1.TXT'
+  # was the argument provided, and the short representation for
+  # 'somefile.txt', then this method would return 'somefile.txt'.
+  #
+  # Note that certain file system optimizations may prevent this method
+  # from working as expected. In that case, you will get back the file
+  # name in 8.3 format.
+  #
+  def self.long_path(file)
+    buffer = FFI::Buffer.new(:wint_t, 1024, true)
+    wfile  = string_check(file).wincode
+
+    length = GetLongPathNameW(wfile, buffer, buffer.size)
+
+    if length == 0 || length > buffer.size / 2
+      raise SystemCallError.new('GetLongPathName', FFI.errno)
+    end
+
+    buffer.read_bytes(length * 2).wstrip
+  end
+
+  # Returns +path+ in 8.3 format. For example, 'c:\documentation.doc'
+  # would be returned as 'c:\docume~1.doc'.
+  #
+  def self.short_path(file)
+    buffer = FFI::Buffer.new(:wint_t, 1024, true)
+    wfile  = string_check(file).wincode
+
+    length = GetShortPathNameW(wfile, buffer, buffer.size)
+
+    if length == 0 || length > buffer.size / 2
+      raise SystemCallError.new('GetShortPathName', FFI.errno)
+    end
+
+    buffer.read_bytes(length * 2).wstrip
+  end
+
+  # Creates a symbolic link called +new_name+ for the file or directory
+  # +old_name+.
+  #
+  # This method requires Windows Vista or later to work. Otherwise, it
+  # returns nil as per MRI.
+  #
+  def self.symlink(target, link)
+    target = string_check(target)
+    link = string_check(link)
+
+    flags = File.directory?(target) ? 1 : 0
+
+    wlink = link.wincode
+    wtarget = target.wincode
+
+    unless CreateSymbolicLinkW(wlink, wtarget, flags)
+      raise SystemCallError.new('CreateSymbolicLink', FFI.errno)
+    end
+
+    0 # Comply with spec
+  end
+
+  # Returns whether or not +file+ is a symlink.
+  #
+  def self.symlink?(file)
+    return false unless File.exist?(file)
+
+    bool  = false
+    wfile = string_check(file).wincode
+
+    attrib = GetFileAttributesW(wfile)
+
+    if attrib == INVALID_FILE_ATTRIBUTES
+      raise SystemCallError.new('GetFileAttributes', FFI.errno)
+    end
+
+    if attrib & FILE_ATTRIBUTE_REPARSE_POINT > 0
+      begin
+        find_data = WIN32_FIND_DATA.new
+        handle = FindFirstFileW(wfile, find_data)
+
+        if handle == INVALID_HANDLE_VALUE
+          raise SystemCallError.new('FindFirstFile', FFI.errno)
+        end
+
+        if find_data[:dwReserved0] == IO_REPARSE_TAG_SYMLINK
+          bool = true
+        end
+      ensure
+        CloseHandle(handle)
+      end
+    end
+
+    bool
+  end
+
+  # Converts path to a full file path, with all symlinks resolved and relative
+  # paths made absolute. If a second parameter if present, it is used as the
+  # base for resolving leading relative path segments.
+  #
+  # Unlike File.realpath, an error is not raised if the final path created
+  # using a relative path argument doesn't exist.
+  #--
+  # On Windows we only modify the realpath method if the file is a symlink.
+  #
+  def self.realdirpath(file, relative_to = nil)
+    file = string_check(file)
+
+    if symlink?(file)
+      if relative_to
+        File.join(relative_to, File.basename(readlink(file)))
+      else
+        readlink(file)
+      end
+    else
+      realdirpath_orig(file, relative_to)
+    end
+  end
+
+  # Converts path to a full file path, with all symlinks resolved and relative
+  # paths made absolute. If a second parameter if present, it is used as the
+  # base for resolving leading relative path segments.
+  #--
+  # On Windows we only modify the realpath method if the file is a symlink.
+  #
+  def self.realpath(file, relative_to = nil)
+    file = string_check(file)
+    relative_to = string_check(relative_to) if relative_to
+
+    if symlink?(file)
+      if relative_to
+        result = File.join(relative_to, File.basename(readlink(file)))
+        if File.exist?(result)
+          result
+        else
+          raise SystemCallError.new(result, 2) # Errno::ENOENT
+        end
+      else
+        readlink(file)
+      end
+    else
+      realpath_orig(file, relative_to)
+    end
+  end
+
+  # Returns the path of the of the symbolic link referred to by +file+.
+  #
+  # Unlike unixy platforms, this will raise an error if the link is stale.
+  #
+  def self.readlink(file)
+    file = string_check(file)
+
+    if exist?(file) && !symlink?(file)
+      raise SystemCallError.new(22) # EINVAL, match the spec
+    end
+
+    wfile = file.wincode
+    path  = 0.chr * 1024
+
+    if File.directory?(file)
+      flags = FILE_FLAG_BACKUP_SEMANTICS
+    else
+      flags = FILE_ATTRIBUTE_NORMAL
+    end
+
+    begin
+      handle = CreateFileW(
+        wfile,
+        GENERIC_READ,
+        FILE_SHARE_READ,
+        nil,
+        OPEN_EXISTING,
+        flags,
+        0
+      )
+
+      if handle == INVALID_HANDLE_VALUE
+        raise SystemCallError.new('CreateFile', FFI.errno)
+      end
+
+      if GetFinalPathNameByHandleW(handle, path, path.size/2, 0) == 0
+        raise SystemCallError.new('GetFinalPathNameByHandle', FFI.errno)
+      end
+    ensure
+      CloseHandle(handle)
+    end
+
+    path.wstrip[4..-1] # Remove leading backslashes + question mark
+  end
+
+  ## STAT METHODS
+
+  # Returns the file's last access time. If a +time+ argument is provided, it
+  # sets the file's access time. The +time+ argument may be a Time object or
+  # a numeric value.
+  #
+  def self.atime(file, time = nil)
+    set_filetime(file, nil, time) if time
+    File::Stat.new(file).atime
+  end
+
+  # Returns the filesystem's block size.
+  #
+  def self.blksize(file)
+    File::Stat.new(file).blksize
+  end
+
+  # Returns whether or not the file is a block device. For MS Windows a
+  # block device is a removable drive, cdrom or ramdisk.
+  #
+  def self.blockdev?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).blockdev?
+  end
+
+  # Returns whether or not the file is a character device.
+  #
+  def self.chardev?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).chardev?
+  end
+
+  # Returns the file's creation time. If a +time+ argument is provided, it
+  # sets the file's creation time. The +time+ argument may be a Time object or
+  # a numeric value.
+  #
+  def self.ctime(file, time = nil)
+    set_filetime(file, time) if time
+    File::Stat.new(file).ctime
+  end
+
+  # Returns whether or not the file is a directory.
+  #
+  def self.directory?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).directory?
+  end
+
+  # Returns whether or not the file is executable.
+  #
+  def self.executable?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).executable?
+  end
+
+  # Returns whether or not the file is a regular file.
+  #
+  def self.file?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).file?
+  end
+
+  # Identifies the type of file. The return string is one of 'file',
+  # 'directory', 'characterSpecial', 'socket' or 'unknown'.
+  #
+  def self.ftype(file)
+    File::Stat.new(file).ftype
+  end
+
+  # Returns true if the process owner's ID is the same as one of the file's groups.
+  #
+  def self.grpowned?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).grpowned?
+  end
+
+  # Returns the file's creation time. If a +time+ argument is provided, it
+  # sets the file's creation time. The +time+ argument may be a Time object or
+  # a numeric value.
+  #
+  def self.mtime(file, time = nil)
+    set_filetime(file, nil, nil, time) if time
+    File::Stat.new(file).mtime
+  end
+
+  # Returns whether or not the current process owner is the owner of the file.
+  #
+  def self.owned?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).owned?
+  end
+
+  # Returns whether or not the file is a pipe.
+  #
+  def self.pipe?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).pipe?
+  end
+
+  # Returns whether or not the file is readable by the process owner.
+  #
+  def self.readable?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).readable?
+  end
+
+  # Synonym for File.readable?
+  #
+  def self.readable_real?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).readable_real?
+  end
+
+  # Returns a File::Stat object as defined in the win32-file-stat library.
+  #
+  def self.stat(file)
+    File::Stat.new(file)
+  end
+
+  # Returns whether or not the file is readable by others. Note that this
+  # merely returns true or false, not permission bits (or nil).
+  #
+  def self.world_readable?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).world_readable?
+  end
+
+  # Returns whether or not the file is writable by others. Note that this
+  # merely returns true or false, not permission bits (or nil).
+  #
+  def self.world_writable?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).world_writable?
+  end
+
+  # Returns whether or not the file is writable by the current process owner.
+  #
+  def self.writable?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).writable?
+  end
+
+  # Synonym for File.writable?
+  #
+  def self.writable_real?(file)
+    return false unless File.exist?(file)
+    File::Stat.new(file).writable_real?
+  end
+
+  # Singleton aliases
+  class << self
+    alias lstat stat
+    alias executable_real? executable?
+    alias socket? pipe?
+  end
+
+  ## Instance Methods
+
+  # Same as MRI, except it returns a stat object using the win32-file-stat gem.
+  #
+  def stat
+    File::Stat.new(self.path)
+  end
+
+  # Private singleton methods
+  private
+
+  # Simulate Ruby's string checking
+  def self.string_check(arg)
+    return arg if arg.is_a?(String)
+    return arg.send(:to_str) if arg.respond_to?(:to_str, true) # MRI allows private to_str
+    return arg.to_path if arg.respond_to?(:to_path)
+    raise TypeError
+  end
+
+  # Internal method for setting the file time.
+  def self.set_filetime(path, ctime = nil, atime = nil, mtime = nil)
+    begin
+      handle = CreateFileW(
+        path.wincode,
+        FILE_WRITE_ATTRIBUTES,
+        FILE_SHARE_READ | FILE_SHARE_WRITE,
+        nil,
+        OPEN_EXISTING,
+        FILE_ATTRIBUTE_NORMAL,
+        0
+      )
+
+      if handle == INVALID_HANDLE_VALUE
+        raise SystemCallError.new('CreateFile', FFI.errno)
+      end
+
+      ftimes = [] # 0 = ctime, 1 = atime, 2 = mtime
+
+      [ctime, atime, mtime].each{ |time|
+        if time.nil?
+          ftimes << nil
+          next
+        else
+          systime = SYSTEMTIME.new(time)
+          ftime = FILETIME.new
+
+          if SystemTimeToFileTime(systime, ftime)
+            ftimes << ftime
+          else
+            raise SystemCallError.new('SystemTimetoFileTime', FFI.errno)
+          end
+        end
+      }
+
+      unless SetFileTime(handle, ftimes[0], ftimes[1], ftimes[2])
+        raise SystemCallError.new('SetFileTime', FFI.errno)
+      end
+    ensure
+      CloseHandle(handle) if handle
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/win32-file-0.8.1/lib/win32-file.rb

@@ -0,0 +1 @@
+require_relative 'win32/file'