pdk 1.9.0 → 3.2.0

data/lib/pdk/util/template_uri.rb

@@ -0,0 +1,283 @@
+require 'pdk'
+
+module PDK
+  module Util
+    class TemplateURI
+      SCP_PATTERN = %r{\A(?!\w+://)(?:(?<user>.+?)@)?(?<host>[^:/]+):(?<path>.+)\z}.freeze
+
+      PACKAGED_TEMPLATE_KEYWORD = 'pdk-default'.freeze
+      DEPRECATED_TEMPLATE_URL = 'https://github.com/puppetlabs/pdk-module-template'.freeze
+      PDK_TEMPLATE_URL = 'https://github.com/puppetlabs/pdk-templates'.freeze
+
+      LEGACY_PACKAGED_TEMPLATE_PATHS = {
+        'windows' => 'file:///C:/Program Files/Puppet Labs/DevelopmentKit/share/cache/pdk-templates.git',
+        'macos' => 'file:///opt/puppetlabs/pdk/share/cache/pdk-templates.git',
+        'linux' => 'file:///opt/puppetlabs/pdk/share/cache/pdk-templates.git'
+      }.freeze
+
+      # XXX Previously
+      # - template_uri used to get the string form of the uri when generating the module and written to pdk answers and metadata
+      # - template_path or deuri_path used for humans to see and commands to run
+      # - uri_path used only internally by the template selection code; move out
+      # - template_ref used by git checkout
+      attr_reader :uri
+
+      # input/output formats:
+      #
+      # file:///c:/foo (git clone location)
+      # c:/foo (shell paths)
+      # file:///c:/foo#main (only for metadata)
+      # c:/foo#main (only for metadata)
+      #
+      # non output formats:
+      #
+      # /c:/foo (internal use only)
+      # /c:/foo#main (internal use only)
+      #
+      def initialize(opts_or_uri)
+        require 'addressable'
+        # If a uri string is passed, skip the valid uri finding code.
+        @uri = case opts_or_uri
+               when self.class
+                 opts_or_uri.uri
+               when String
+                 begin
+                   uri, ref = opts_or_uri.split('#', 2)
+                   if PDK::Util::TemplateURI.packaged_template?(uri)
+                     PDK::Util::TemplateURI.default_template_addressable_uri.tap { |default| default.fragment = ref unless ref.nil? || ref.empty? }
+                   else
+                     Addressable::URI.parse(opts_or_uri)
+                   end
+                 rescue Addressable::URI::InvalidURIError
+                   raise PDK::CLI::FatalError, "PDK::Util::TemplateURI attempted initialization with a non-uri string: #{opts_or_uri}"
+                 end
+               when Addressable::URI
+                 opts_or_uri.dup
+               else
+                 PDK::Util::TemplateURI.first_valid_uri(PDK::Util::TemplateURI.templates(opts_or_uri))
+               end
+      end
+
+      def ==(other)
+        @uri == other.uri
+      end
+
+      def bare_uri
+        PDK::Util::TemplateURI.bare_uri(@uri)
+      end
+
+      # This is the URI represented in a format suitable for writing to
+      # metadata.
+      #
+      # @returns String
+      def metadata_format
+        @metadata_format ||= if PDK::Util::TemplateURI.packaged_template?(bare_uri)
+                               PDK::Util::TemplateURI.human_readable("pdk-default##{uri_fragment}")
+                             else
+                               PDK::Util::TemplateURI.human_readable(@uri.to_s)
+                             end
+      end
+      alias to_s metadata_format
+      alias to_str metadata_format
+
+      # Returns the fragment of the URI, of the default template's ref if one does not exist
+      # @returns String
+      # @api private
+      def uri_fragment
+        @uri.fragment || self.class.default_template_ref(self)
+      end
+
+      def uri_fragment=(fragment)
+        @uri.fragment = fragment
+      end
+
+      def default?
+        bare_uri == PDK::Util::TemplateURI.bare_uri(PDK::Util::TemplateURI.default_template_addressable_uri)
+      end
+
+      def default_ref?
+        uri_fragment == self.class.default_template_ref(self)
+      end
+
+      def puppetlabs_template?
+        self.class.packaged_template?(bare_uri) || bare_uri == PDK_TEMPLATE_URL
+      end
+
+      # Class Methods
+
+      # Remove the fragment off of URI. Useful for removing the branch
+      # for Git based URIs
+      def self.bare_uri(uri)
+        require 'addressable'
+
+        if uri.is_a?(Addressable::URI) && uri.fragment
+          human_readable(uri.to_s.chomp("##{uri.fragment}"))
+        else
+          human_readable(uri.to_s)
+        end
+      end
+
+      # This is the path of the URI, suitable for accessing directly from the shell.
+      # @returns String
+      def shell_path
+        self.class.human_readable(@uri.path)
+      end
+
+      # @returns PDK::Util::TemplateURI
+      def self.default_template_uri
+        require 'pdk/util'
+        require 'addressable'
+
+        PDK::Util::TemplateURI.new(default_template_addressable_uri)
+      end
+
+      # @returns Addressable::URI
+      # @api private
+      def self.default_template_addressable_uri
+        require 'pdk/util'
+        require 'addressable'
+
+        if PDK::Util.package_install?
+          Addressable::URI.new(scheme: 'file', host: '', path: File.join(PDK::Util.package_cachedir, 'pdk-templates.git'))
+        else
+          Addressable::URI.parse(PDK_TEMPLATE_URL)
+        end
+      end
+
+      # `C:...` urls are not URI-safe. They should be of the form `/C:...` to
+      # be URI-safe. scp-like urls like `user@host:/path` are not URI-safe
+      # either and so are subsequently converted to ssh:// URIs.
+      #
+      # @returns String
+      def self.uri_safe(string)
+        url = Gem.win_platform? && string =~ /^[a-zA-Z][|:]/ ? "/#{string}" : string
+        parse_scp_url(url)
+      end
+
+      # If the passed value is a URI-safe windows path such as `/C:...` then it
+      # should be changed to a human-friendly `C:...` form. Otherwise the
+      # passed value is left alone.
+      #
+      # @returns String
+      def self.human_readable(string)
+        Gem.win_platform? && string =~ %r{^/[a-zA-Z][|:]} ? string[1..] : string
+      end
+
+      def self.parse_scp_url(url)
+        require 'pathname'
+        require 'addressable'
+
+        # Valid URIs to avoid catching:
+        # - absolute local paths
+        # - have :'s in paths when preceeded by a slash
+        # - have only digits following the : and preceeding a / or end-of-string that is 0-65535
+        # The last item is ambiguous in the case of scp/git paths vs. URI port
+        # numbers, but can be made unambiguous by making the form to
+        # ssh://git@github.com/1234/repo.git or
+        # ssh://git@github.com:1234/user/repo.git
+        scp_url = url.match(SCP_PATTERN)
+        return url unless Pathname.new(url).relative? && scp_url
+
+        uri = Addressable::URI.new(scheme: 'ssh', user: scp_url[:user], host: scp_url[:host], path: scp_url[:path])
+        PDK.logger.warn format('%{scp_uri} appears to be an SCP style URL; it will be converted to an RFC compliant URI: %{rfc_uri}', scp_uri: url, rfc_uri: uri.to_s)
+
+        uri.to_s
+      end
+
+      # @return [Array<Hash{Symbol => Object}>] an array of hashes. Each hash
+      #   contains 3 keys: :type contains a String that describes the template
+      #   directory, :url contains a String with the URL to the template
+      #   directory, and :allow_fallback contains a Boolean that specifies if
+      #   the lookup process should proceed to the next template directory if
+      #   the template file is not in this template directory.
+      def self.templates(opts)
+        require 'pdk/answer_file'
+        require 'pdk/util'
+        require 'addressable'
+
+        explicit_url = opts.fetch(:'template-url', nil)
+        explicit_ref = opts.fetch(:'template-ref', nil)
+
+        # 1. Get the CLI, metadata (or answers if no metadata), and default URIs
+        # 2. Construct the hash
+        if explicit_url
+          explicit_uri = Addressable::URI.parse(uri_safe(explicit_url))
+          explicit_uri.fragment = explicit_ref || default_template_ref(new(explicit_uri))
+        else
+          explicit_uri = nil
+        end
+        metadata_uri = if PDK::Util.module_root && PDK::Util::Filesystem.file?(File.join(PDK::Util.module_root, 'metadata.json')) && PDK::Util.module_metadata['template-url']
+                         new(uri_safe(PDK::Util.module_metadata['template-url'])).uri
+                       end
+        default_template_url = PDK.config.get_within_scopes('module_defaults.template-url')
+        answers_uri = if [PACKAGED_TEMPLATE_KEYWORD, DEPRECATED_TEMPLATE_URL].include?(default_template_url)
+                        Addressable::URI.parse(default_template_uri)
+                      elsif default_template_url
+                        new(uri_safe(default_template_url)).uri
+                      end
+        default_uri = default_template_uri.uri
+        default_uri.fragment = default_template_ref(default_template_uri)
+
+        ary = []
+        ary << { type: '--template-url', uri: explicit_uri, allow_fallback: false } if explicit_url
+        ary << { type: 'metadata.json', uri: metadata_uri, allow_fallback: true } if metadata_uri
+        ary << { type: 'PDK answers', uri: answers_uri, allow_fallback: true } if answers_uri
+        ary << { type: 'default', uri: default_uri, allow_fallback: false }
+        ary
+      end
+
+      # @returns String
+      def self.default_template_ref(uri = nil)
+        require 'pdk/util'
+        require 'pdk/version'
+
+        return 'main' if PDK::Util.development_mode?
+        return PDK::TEMPLATE_REF if uri.nil?
+
+        uri = new(uri) unless uri.is_a?(self)
+        uri.default? ? PDK::TEMPLATE_REF : 'main'
+      end
+
+      # @returns Addressable::URI
+      def self.first_valid_uri(templates_array)
+        # 1. Get the four sources of URIs
+        # 2. Pick the first non-nil URI
+        # 3. Error if the URI is not a valid git repo (missing directory or http 404)
+        # 4. Leave updating answers/metadata to other code
+        found_template = templates_array.find { |t| valid_template?(t) }
+
+        raise PDK::CLI::FatalError, 'Unable to find a valid module template to use.' if found_template.nil?
+
+        found_template[:uri]
+      end
+
+      def self.valid_template?(template, context = PDK.context)
+        require 'addressable'
+
+        return false if template.nil? || !template.is_a?(Hash)
+        return false if template[:uri].nil? || !template[:uri].is_a?(Addressable::URI)
+
+        return true if PDK::Util::Git.repo?(bare_uri(template[:uri]))
+
+        path = human_readable(template[:uri].path)
+        if PDK::Util::Filesystem.directory?(path)
+          # We know that it's not a git repository, but it's a valid path on disk
+          begin
+            renderer = PDK::Template::Renderer.instance(path, template[:uri], context)
+            return !renderer.nil?
+          rescue StandardError
+            nil
+          end
+        end
+
+        raise PDK::CLI::FatalError, format('Unable to find a valid template at %{uri}', uri: template[:uri].to_s) unless template[:allow_fallback]
+
+        false
+      end
+
+      def self.packaged_template?(path)
+        path == PACKAGED_TEMPLATE_KEYWORD || LEGACY_PACKAGED_TEMPLATE_PATHS.value?(path)
+      end
+    end
+  end
+end

data/lib/pdk/util/vendored_file.rb

@@ -1,29 +1,11 @@
-require 'pdk/util'
-require 'net/https'
-require 'openssl'
-require 'fileutils'
-require 'pdk/util/filesystem'
+require 'pdk'
 
 module PDK
   module Util
     class VendoredFile
       class DownloadError < StandardError; end
 
-      HTTP_ERRORS = [
-        EOFError,
-        Errno::ECONNRESET,
-        Errno::EINVAL,
-        Errno::ECONNREFUSED,
-        Net::HTTPBadResponse,
-        Net::HTTPHeaderSyntaxError,
-        Net::ProtocolError,
-        Timeout::Error,
-      ].freeze
-
-      attr_reader :file_name
-      attr_reader :url
-
-      include PDK::Util::Filesystem
+      attr_reader :file_name, :url
 
       def initialize(file_name, url)
         @file_name = file_name
@@ -31,56 +13,66 @@ module PDK
       end
 
       def read
-        return File.read(package_vendored_path) if PDK::Util.package_install?
-        return File.read(gem_vendored_path) if File.file?(gem_vendored_path)
+        require 'pdk/util'
+        require 'pdk/util/filesystem'
+
+        return PDK::Util::Filesystem.read_file(package_vendored_path) if PDK::Util.package_install?
+        return PDK::Util::Filesystem.read_file(gem_vendored_path) if PDK::Util::Filesystem.file?(gem_vendored_path)
 
         content = download_file
 
         # TODO: should only write if it's valid JSON
         # TODO: need a way to invalidate if out of date
-        FileUtils.mkdir_p(File.dirname(gem_vendored_path))
-        write_file(gem_vendored_path, content)
+        PDK::Util::Filesystem.mkdir_p(File.dirname(gem_vendored_path))
+        PDK::Util::Filesystem.write_file(gem_vendored_path, content)
         content
       end
 
       private
 
       def download_file
-        PDK.logger.debug _('%{file_name} was not found in the cache, downloading it from %{url}.') % {
-          file_name: file_name,
-          url:       url,
-        }
+        require 'uri'
+        require 'net/https'
+        require 'openssl'
+
+        http_errors = [
+          EOFError,
+          Errno::ECONNRESET,
+          Errno::EINVAL,
+          Errno::ECONNREFUSED,
+          Net::HTTPBadResponse,
+          Net::HTTPHeaderSyntaxError,
+          Net::ProtocolError,
+          Timeout::Error
+        ]
+
+        PDK.logger.debug format('%{file_name} was not found in the cache, downloading it from %{url}.', file_name: file_name, url: url)
 
         uri = URI.parse(url)
         http = Net::HTTP.new(uri.host, uri.port)
         http.use_ssl = true
-        # TODO: Get rid of this, possible workaround:
-        # https://github.com/glennsarti/dev-tools/blob/master/RubyCerts.ps1
+        # TODO: Get rid of this
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE if Gem.win_platform?
         request = Net::HTTP::Get.new(uri.request_uri)
         response = http.request(request)
 
-        unless response.code == '200'
-          raise DownloadError, _('Unable to download %{url}. %{code}: %{message}.') % {
-            url:     url,
-            code:    response.code,
-            message: response.message,
-          }
-        end
+        raise DownloadError, format('Unable to download %{url}. %{code}: %{message}.', url: url, code: response.code, message: response.message) unless response.code == '200'
 
         response.body
-      rescue *HTTP_ERRORS => e
-        raise DownloadError, _('Unable to download %{url}. Check internet connectivity and try again. %{error}') % {
-          url: url,
-          error: e,
-        }
+      rescue *http_errors => e
+        raise DownloadError, format('Unable to download %{url}. Check internet connectivity and try again. %{error}', url: url, error: e)
       end
 
       def package_vendored_path
+        require 'pdk/util'
+
         @package_vendored_path ||= File.join(PDK::Util.package_cachedir, file_name)
       end
 
       def gem_vendored_path
+        require 'pdk/util'
+        require 'pdk/version'
+
         @gem_vendored_path ||= File.join(PDK::Util.cachedir, PDK::VERSION, file_name)
       end
     end

data/lib/pdk/util/version.rb

@@ -1,12 +1,11 @@
-require 'pdk/version'
-require 'pdk/cli/exec'
-require 'pdk/util/git'
-require 'pdk/logger'
+require 'pdk'
 
 module PDK
   module Util
     module Version
       def self.version_string
+        require 'pdk/version'
+
         "#{PDK::VERSION} #{pdk_ref}".strip.freeze
       end
 
@@ -16,8 +15,8 @@ module PDK
       end
 
       def self.pkg_sha
-        if version_file && File.exist?(version_file)
-          ver = File.read(version_file)
+        if version_file && PDK::Util::Filesystem.exist?(version_file)
+          ver = PDK::Util::Filesystem.read_file(version_file)
           sha = ver.strip.split('.')[5] unless ver.nil?
         end
 
@@ -25,15 +24,17 @@ module PDK
       end
 
       def self.git_ref
-        source_git_dir = File.join(File.expand_path('../../..', File.dirname(__FILE__)), '.git')
+        require 'pdk/util/git'
+        source_git_dir = File.join(PDK::Util::Filesystem.expand_path('../../..', File.dirname(__FILE__)), '.git')
 
-        return nil unless File.directory?(source_git_dir)
+        return unless PDK::Util::Filesystem.directory?(source_git_dir)
 
-        ref_result = PDK::Util::Git.git('--git-dir', source_git_dir, 'describe', '--all', '--long')
-        return ref_result[:stdout].strip if ref_result[:exit_code].zero?
+        PDK::Util::Git.describe(source_git_dir)
       end
 
       def self.version_file
+        require 'pdk/util'
+
         # FIXME: this gets called a LOT and doesn't currently get cached
         PDK::Util.find_upwards('PDK_VERSION', File.dirname(__FILE__))
       end

data/lib/pdk/util/windows/api_types.rb

@@ -1,57 +1,87 @@
 require 'ffi'
 require 'pdk/util/windows/string'
 
-module PDK::Util::Windows::APITypes
-  module ::FFI
-    WIN32_FALSE = 0
+module PDK
+  module Util
+    module Windows
+      module APITypes
+        module ::FFI
+          module Library
+            def attach_function_private(*args)
+              attach_function(*args)
+              private args[0]
+            end
+          end
+        end
 
-    # standard Win32 error codes
-    ERROR_SUCCESS = 0
-  end
+        module ::FFI
+          class Pointer
+            def self.from_string_to_wide_string(str, &_block)
+              str = PDK::Util::Windows::String.wide_string(str)
+              FFI::MemoryPointer.new(:byte, str.bytesize) do |ptr|
+                # uchar here is synonymous with byte
+                ptr.put_array_of_uchar(0, str.bytes.to_a)
 
-  class ::FFI::Pointer
-    def self.from_string_to_wide_string(str, &_block)
-      str = PDK::Util::Windows::String.wide_string(str)
-      FFI::MemoryPointer.new(:byte, str.bytesize) do |ptr|
-        # uchar here is synonymous with byte
-        ptr.put_array_of_uchar(0, str.bytes.to_a)
+                yield ptr
+              end
 
-        yield ptr
-      end
+              # ptr has already had free called, so nothing to return
+              nil
+            end
 
-      # ptr has already had free called, so nothing to return
-      nil
-    end
+            def read_wide_string(char_length, dst_encoding = Encoding::UTF_8, encode_options = {})
+              # char_length is number of wide chars (typically excluding NULLs), *not* bytes
+              str = get_bytes(0, char_length * 2).force_encoding('UTF-16LE')
+              str.encode(dst_encoding, str.encoding, **encode_options)
+            rescue StandardError => e
+              PDK.logger.debug format('Unable to convert value %{string} to encoding %{encoding} due to %{error}', string: str.dump, encoding: dst_encoding, error: e.inspect)
+              raise
+            end
 
-    def read_wide_string(char_length, dst_encoding = Encoding::UTF_8, encode_options = {})
-      # char_length is number of wide chars (typically excluding NULLs), *not* bytes
-      str = get_bytes(0, char_length * 2).force_encoding('UTF-16LE')
-      str.encode(dst_encoding, str.encoding, encode_options)
-    rescue StandardError => e
-      PDK.logger.debug _('Unable to convert value %{string} to encoding %{encoding} due to %{error}') % {
-        string:   str.dump,
-        encoding: dst_encoding,
-        error:    e.inspect,
-      }
-      raise
-    end
-  end
+            def read_arbitrary_wide_string_up_to(max_char_length = 512, null_terminator = :single_null, encode_options = {})
+              unless [:single_null, :double_null].include?(null_terminator)
+                raise ArgumentError,
+                      format('Unable to read wide strings with %{null_terminator} terminal nulls', null_terminator: null_terminator)
+              end
+
+              terminator_width = null_terminator == :single_null ? 1 : 2
+              reader_method = null_terminator == :single_null ? :get_uint16 : :get_uint32
 
-  # FFI Types
-  # https://github.com/ffi/ffi/wiki/Types
+              # Look for the null_terminator; if found, read up to that null
+              # (exclusive)
+              (0...max_char_length - terminator_width).each do |i|
+                return read_wide_string(i, Encoding::UTF_8, encode_options) if send(reader_method, (i * 2)).zero?
+              end
 
-  # Windows - Common Data Types
-  # https://msdn.microsoft.com/en-us/library/cc230309.aspx
+              # String is longer than the max, read just up to the max
+              read_wide_string(max_char_length, Encoding::UTF_8, encode_options)
+            end
+          end
+        end
 
-  # Windows Data Types
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
+        # FFI Types
+        # https://github.com/ffi/ffi/wiki/Types
 
-  FFI.typedef :uint32, :dword
-  # buffer_inout is similar to pointer (platform specific), but optimized for buffers
-  FFI.typedef :buffer_inout, :lpwstr
-  # buffer_in is similar to pointer (platform specific), but optimized for CONST read only buffers
-  FFI.typedef :buffer_in, :lpcwstr
-  # 8 bits per byte
-  FFI.typedef :uchar, :byte
-  FFI.typedef :uint16, :wchar
+        # Windows - Common Data Types
+        # https://msdn.microsoft.com/en-us/library/cc230309.aspx
+
+        # Windows Data Types
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
+
+        FFI.typedef :uint32, :dword
+        # buffer_inout is similar to pointer (platform specific), but optimized for buffers
+        FFI.typedef :buffer_inout, :lpwstr
+        # buffer_in is similar to pointer (platform specific), but optimized for CONST read only buffers
+        FFI.typedef :buffer_in, :lpcwstr
+        # 8 bits per byte
+        FFI.typedef :uchar, :byte
+        FFI.typedef :uint16, :wchar
+
+        # FFI bool can be only 1 byte at times,
+        # Win32 BOOL is a signed int, and is always 4 bytes, even on x64
+        # https://blogs.msdn.com/b/oldnewthing/archive/2011/03/28/10146459.aspx
+        FFI.typedef :int32, :win32_bool
+      end
+    end
+  end
 end

data/lib/pdk/util/windows/file.rb

@@ -1,36 +1,40 @@
 require 'pdk/util/windows'
 
-module PDK::Util::Windows::File
-  require 'ffi'
-  extend FFI::Library
-  extend PDK::Util::Windows::String
+module PDK
+  module Util
+    module Windows
+      module File
+        require 'ffi'
+        extend FFI::Library
+        extend PDK::Util::Windows::String
 
-  def get_long_pathname(path)
-    converted = ''
-    FFI::Pointer.from_string_to_wide_string(path) do |path_ptr|
-      # includes terminating NULL
-      buffer_size = GetLongPathNameW(path_ptr, FFI::Pointer::NULL, 0)
-      FFI::MemoryPointer.new(:wchar, buffer_size) do |converted_ptr|
-        if GetLongPathNameW(path_ptr, converted_ptr, buffer_size) == FFI::WIN32_FALSE
-          raise _('Failed to call GetLongPathName')
+        def get_long_pathname(path)
+          converted = ''
+          FFI::Pointer.from_string_to_wide_string(path) do |path_ptr|
+            # includes terminating NULL
+            buffer_size = GetLongPathNameW(path_ptr, FFI::Pointer::NULL, 0)
+            FFI::MemoryPointer.new(:wchar, buffer_size) do |converted_ptr|
+              raise 'Failed to call GetLongPathName' if GetLongPathNameW(path_ptr, converted_ptr, buffer_size) == PDK::Util::Windows::WIN32_FALSE
+
+              converted = converted_ptr.read_wide_string(buffer_size - 1)
+            end
+          end
+
+          converted
         end
+        module_function :get_long_pathname
+
+        ffi_convention :stdcall
 
-        converted = converted_ptr.read_wide_string(buffer_size - 1)
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa364980(v=vs.85).aspx
+        # DWORD WINAPI GetLongPathName(
+        #   _In_  LPCTSTR lpszShortPath,
+        #   _Out_ LPTSTR  lpszLongPath,
+        #   _In_  DWORD   cchBuffer
+        # );
+        ffi_lib :kernel32
+        attach_function :GetLongPathNameW, [:lpcwstr, :lpwstr, :dword], :dword
       end
     end
-
-    converted
   end
-  module_function :get_long_pathname
-
-  ffi_convention :stdcall
-
-  # https://msdn.microsoft.com/en-us/library/windows/desktop/aa364980(v=vs.85).aspx
-  # DWORD WINAPI GetLongPathName(
-  #   _In_  LPCTSTR lpszShortPath,
-  #   _Out_ LPTSTR  lpszLongPath,
-  #   _In_  DWORD   cchBuffer
-  # );
-  ffi_lib :kernel32
-  attach_function :GetLongPathNameW, [:lpcwstr, :lpwstr, :dword], :dword
 end