pdk 2.7.0 → 3.0.0

data/lib/pdk/util/git.rb

@@ -3,10 +3,7 @@ require 'pdk'
 module PDK
   module Util
     class GitError < StandardError
-      attr_reader :stdout
-      attr_reader :stderr
-      attr_reader :exit_code
-      attr_reader :args
+      attr_reader :stdout, :stderr, :exit_code, :args
 
       def initialze(args, result)
         @args = args
@@ -14,12 +11,12 @@ module PDK
         @stderr = result[:stderr]
         @exit_code = result[:exit_code]
 
-        super('Git command failed: git %{args}' % { args: args.join(' ') })
+        super(format('Git command failed: git %{args}', args: args.join(' ')))
       end
     end
 
     module Git
-      GIT_QUERY_CACHE_TTL ||= 10
+      GIT_QUERY_CACHE_TTL = 10
 
       def self.git_bindir
         @git_dir ||= File.join('private', 'git', Gem.win_platform? ? 'cmd' : 'bin')
@@ -67,6 +64,7 @@ module PDK
       def self.repo?(maybe_repo)
         result = cached_git_query(maybe_repo, :repo?)
         return result unless result.nil?
+
         result = if PDK::Util::Filesystem.directory?(maybe_repo)
                    # Use boolean shortcircuiting here. The mostly likely type of git repo
                    # is a "normal" repo with a working tree. Bare repos do not have work tree
@@ -90,6 +88,7 @@ module PDK
 
       def self.work_tree?(path)
         return false unless PDK::Util::Filesystem.directory?(path)
+
         result = cached_git_query(path, :work_tree?)
         return result unless result.nil?
 
@@ -100,30 +99,27 @@ module PDK
       end
 
       def self.work_dir_clean?(repo)
-        raise PDK::CLI::ExitWithError, 'Unable to locate git work dir "%{workdir}"' % { workdir: repo } unless PDK::Util::Filesystem.directory?(repo)
-        raise PDK::CLI::ExitWithError, 'Unable to locate git dir "%{gitdir}"' % { gitdir: repo } unless PDK::Util::Filesystem.directory?(File.join(repo, '.git'))
+        raise PDK::CLI::ExitWithError, format('Unable to locate git work dir "%{workdir}"', workdir: repo) unless PDK::Util::Filesystem.directory?(repo)
+        raise PDK::CLI::ExitWithError, format('Unable to locate git dir "%{gitdir}"', gitdir: repo) unless PDK::Util::Filesystem.directory?(File.join(repo, '.git'))
 
         git('--work-tree', repo, '--git-dir', File.join(repo, '.git'), 'status', '--untracked-files=no', '--porcelain', repo)[:stdout].empty?
       end
 
       def self.ls_remote(repo, ref)
-        if PDK::Util::Filesystem.directory?(repo)
-          repo = 'file://' + repo
-        end
+        repo = "file://#{repo}" if PDK::Util::Filesystem.directory?(repo)
 
         output = git('ls-remote', '--refs', repo, ref)
 
         unless output[:exit_code].zero?
           PDK.logger.error output[:stdout]
           PDK.logger.error output[:stderr]
-          raise PDK::CLI::ExitWithError, 'Unable to access the template repository "%{repository}"' % {
-            repository: repo,
-          }
+          raise PDK::CLI::ExitWithError, format('Unable to access the template repository "%{repository}"', repository: repo)
         end
 
-        matching_refs = output[:stdout].split(%r{\r?\n}).map { |r| r.split("\t") }
-        matching_ref = matching_refs.find { |_sha, remote_ref| remote_ref == "refs/tags/#{ref}" || remote_ref == "refs/remotes/origin/#{ref}" || remote_ref == "refs/heads/#{ref}" }
-        raise PDK::CLI::ExitWithError, 'Unable to find a branch or tag named "%{ref}" in %{repo}' % { ref: ref, repo: repo } if matching_ref.nil?
+        matching_refs = output[:stdout].split(/\r?\n/).map { |r| r.split("\t") }
+        matching_ref = matching_refs.find { |_sha, remote_ref| ["refs/tags/#{ref}", "refs/remotes/origin/#{ref}", "refs/heads/#{ref}"].include?(remote_ref) }
+        raise PDK::CLI::ExitWithError, format('Unable to find a branch or tag named "%{ref}" in %{repo}', ref: ref, repo: repo) if matching_ref.nil?
+
         matching_ref.first
       end
 
@@ -131,6 +127,7 @@ module PDK
         args = ['--git-dir', path, 'describe', '--all', '--long', '--always', ref].compact
         result = git(*args)
         raise PDK::Util::GitError, args, result unless result[:exit_code].zero?
+
         result[:stdout].strip
       end
 
@@ -148,14 +145,12 @@ module PDK
 
       def self.cached_git_query(repo, query)
         # TODO: Not thread safe
-        if @git_repo_expire_cache.nil?
+        if @git_repo_expire_cache.nil? || Time.now > @git_repo_expire_cache
           @git_repo_expire_cache = Time.now + GIT_QUERY_CACHE_TTL # Expire the cache every GIT_QUERY_CACHE_TTL seconds
           @git_repo_cache = {}
-        elsif Time.now > @git_repo_expire_cache
-          @git_repo_expire_cache = Time.now + GIT_QUERY_CACHE_TTL
-          @git_repo_cache = {}
         end
         return nil if @git_repo_cache[repo].nil?
+
         @git_repo_cache[repo][query]
       end
       private_class_method :cached_git_query

data/lib/pdk/util/json_finder.rb

@@ -33,13 +33,14 @@ module PDK
           @scanner.getch until @scanner.peek(1) == '{' || @scanner.eos?
 
           (@objects ||= []) << begin
-                                 JSON.parse(read_object(true) || '')
-                               rescue JSON::ParserError
-                                 nil
-                               end
+            JSON.parse(read_object(true) || '')
+          rescue JSON::ParserError
+            nil
+          end
         end
 
         return [] if @objects.nil?
+
         @objects = @objects.compact
       end
 
@@ -56,7 +57,7 @@ module PDK
         matched_text = new_object ? @scanner.getch : ''
 
         until @scanner.eos?
-          text = @scanner.scan_until(%r{(?:(?<!\\)"|\{|\})})
+          text = @scanner.scan_until(/(?:(?<!\\)"|\{|\})/)
           unless text
             @scanner.terminate
             return nil
@@ -67,7 +68,7 @@ module PDK
           when '}'
             break
           when '"'
-            text = @scanner.scan_until(%r{(?<!\\)"})
+            text = @scanner.scan_until(/(?<!\\)"/)
             unless text
               @scanner.terminate
               return nil

data/lib/pdk/util/puppet_strings.rb

@@ -117,7 +117,7 @@ module PDK
         require 'pdk/generate'
 
         PDK::Generate.generators.find do |gen|
-          gen.const_defined?(:PUPPET_STRINGS_TYPE) && gen::PUPPET_STRINGS_TYPE == type
+          gen.const_defined?(:PUPPET_STRINGS_TYPE) && type == gen::PUPPET_STRINGS_TYPE
         end
       end
     end

data/lib/pdk/util/puppet_version.rb

@@ -25,8 +25,8 @@ module PDK
         require 'pdk/util/ruby_version'
 
         {
-          gem_version: 'file://%{path}' % { path: puppet_dev_path },
-          ruby_version: PDK::Util::RubyVersion.latest_ruby_version,
+          gem_version: format('file://%{path}', path: puppet_dev_path),
+          ruby_version: PDK::Util::RubyVersion.latest_ruby_version
         }
       end
 
@@ -39,9 +39,7 @@ module PDK
       def latest_available
         latest = find_gem(Gem::Requirement.create('>= 0'))
 
-        if latest.nil?
-          raise ArgumentError, 'Unable to find a Puppet gem in current Ruby environment or from Rubygems.org.'
-        end
+        raise ArgumentError, 'Unable to find a Puppet gem in current Ruby environment or from Rubygems.org.' if latest.nil?
 
         latest
       end
@@ -69,7 +67,7 @@ module PDK
 
           PDK.logger.error clone_result[:stdout]
           PDK.logger.error clone_result[:stderr]
-          raise PDK::CLI::FatalError, "Unable to clone git repository from '%{repo}'." % { repo: DEFAULT_PUPPET_DEV_URL }
+          raise PDK::CLI::FatalError, format("Unable to clone git repository from '%{repo}'.", repo: DEFAULT_PUPPET_DEV_URL)
         end
 
         # Fetch Updates from remote repository
@@ -78,7 +76,7 @@ module PDK
         unless fetch_result[:exit_code].zero?
           PDK.logger.error fetch_result[:stdout]
           PDK.logger.error fetch_result[:stderr]
-          raise PDK::CLI::FatalError, "Unable to fetch from git remote at '%{repo}'." % { repo: DEFAULT_PUPPET_DEV_URL }
+          raise PDK::CLI::FatalError, format("Unable to fetch from git remote at '%{repo}'.", repo: DEFAULT_PUPPET_DEV_URL)
         end
 
         # Reset local repo to latest
@@ -89,7 +87,7 @@ module PDK
 
         PDK.logger.error reset_result[:stdout]
         PDK.logger.error reset_result[:stderr]
-        raise PDK::CLI::FatalError, "Unable to update git repository at '%{cachedir}'." % { cachedir: puppet_dev_path }
+        raise PDK::CLI::FatalError, format("Unable to update git repository at '%{cachedir}'.", cachedir: puppet_dev_path)
       end
 
       def find_gem_for(version_str)
@@ -108,18 +106,12 @@ module PDK
         latest_requirement = Gem::Requirement.create(requirement_string)
         latest_available_gem = find_gem(latest_requirement)
 
-        if latest_available_gem.nil?
-          raise ArgumentError, 'Unable to find a Puppet gem matching %{requirement}.' % {
-            requirement: latest_requirement,
-          }
-        end
+        raise ArgumentError, format('Unable to find a Puppet gem matching %{requirement}.', requirement: latest_requirement) if latest_available_gem.nil?
 
         # Only issue this warning if they requested an exact version that isn't available.
         if version.segments.length == 3
-          PDK.logger.warn('Puppet %{requested_version} is not available, activating %{found_version} instead.' % {
-            requested_version: version_str,
-            found_version:     latest_available_gem[:gem_version].version,
-          })
+          PDK.logger.warn(format('Puppet %{requested_version} is not available, activating %{found_version} instead.', requested_version: version_str,
+                                                                                                                       found_version: latest_available_gem[:gem_version].version))
         end
 
         latest_available_gem
@@ -134,20 +126,13 @@ module PDK
         safe_versions = {
           2023 => '7.23.0',
           2021 => '7.23.0',
-          2019 => '6.29.0',
+          2019 => '6.29.0'
         }
 
         gem_version = safe_versions[version.segments[0]]
-        if gem_version.nil?
-          raise ArgumentError, 'Unable to map Puppet Enterprise version %{pe_version} to a Puppet version.' % {
-            pe_version: version_str,
-          }
-        end
+        raise ArgumentError, format('Unable to map Puppet Enterprise version %{pe_version} to a Puppet version.', pe_version: version_str) if gem_version.nil?
 
-        PDK.logger.info 'Puppet Enterprise %{pe_version} maps to Puppet %{puppet_version}.' % {
-          pe_version:     version_str,
-          puppet_version: gem_version,
-        }
+        PDK.logger.info format('Puppet Enterprise %{pe_version} maps to Puppet %{puppet_version}.', pe_version: version_str, puppet_version: gem_version)
 
         find_gem_for(gem_version)
       end
@@ -172,7 +157,7 @@ module PDK
 
         # Split combined requirements like ">= 4.7.0 < 6.0.0" into their
         # component requirements [">= 4.7.0", "< 6.0.0"]
-        pattern = %r{#{Gem::Requirement::PATTERN_RAW}}
+        pattern = /#{Gem::Requirement::PATTERN_RAW}/o
         requirement_strings = metadata_requirement['version_requirement'].scan(pattern).map do |req|
           req.compact.join(' ')
         end
@@ -186,47 +171,11 @@ module PDK
       def parse_specified_version(version_str)
         Gem::Version.new(version_str)
       rescue ArgumentError
-        raise ArgumentError, '%{version} is not a valid version number.' % {
-          version: version_str,
-        }
-      end
-
-      def pe_version_map
-        @pe_version_map ||= fetch_pe_version_map.map { |version_map|
-          maps = version_map['versions'].map do |pe_release|
-            requirements = ["= #{pe_release['version']}"]
-
-            # Some PE release have a .0 Z release, which causes problems when
-            # the user specifies "X.Y" expecting to get the latest Z and
-            # instead getting the oldest.
-            requirements << "!= #{pe_release['version'].gsub(%r{\.\d+\Z}, '')}" if pe_release['version'].end_with?('.0')
-            {
-              requirement: Gem::Requirement.create(requirements),
-              gem_version: pe_release['puppet'],
-            }
-          end
-
-          maps << {
-            requirement: requirement_from_forge_range(version_map['release']),
-            gem_version: version_map['versions'].find { |r| r['version'] == version_map['latest'] }['puppet'],
-          }
-        }.flatten
-      end
-
-      def fetch_pe_version_map
-        require 'pdk/util/vendored_file'
-
-        map = PDK::Util::VendoredFile.new('pe_versions.json', PE_VERSIONS_URL).read
-
-        JSON.parse(map)
-      rescue PDK::Util::VendoredFile::DownloadError => e
-        raise PDK::CLI::FatalError, e.message
-      rescue JSON::ParserError
-        raise PDK::CLI::FatalError, 'Failed to parse Puppet Enterprise version map file.'
+        raise ArgumentError, format('%{version} is not a valid version number.', version: version_str)
       end
 
       def requirement_from_forge_range(range_str)
-        Gem::Requirement.create("~> #{range_str.gsub(%r{\.x\Z}, '.0')}")
+        Gem::Requirement.create("~> #{range_str.gsub(/\.x\Z/, '.0')}")
       end
 
       def rubygems_puppet_versions
@@ -236,7 +185,7 @@ module PDK
             spec_tuple.name == 'puppet' && Gem::Platform.match(spec_tuple.platform)
           end
           puppet_versions = puppet_tuples.map { |name, _| name.version }.uniq
-          puppet_versions.sort { |a, b| b <=> a }
+          puppet_versions.sort.reverse
         end
       end
 

data/lib/pdk/util/ruby_version.rb

@@ -31,23 +31,19 @@ module PDK
         end
 
         def use(version)
-          if versions.key?(version)
-            @active_ruby_version = version
-          else
-            raise ArgumentError, 'Unknown Ruby version "%{ruby_version}"' % {
-              ruby_version: version,
-            }
-          end
+          raise ArgumentError, format('Unknown Ruby version "%{ruby_version}"', ruby_version: version) unless versions.key?(version)
+
+          @active_ruby_version = version
         end
 
         def scan_for_packaged_rubies
           require 'pdk/util'
 
           ruby_basedir = File.join(PDK::Util.pdk_package_basedir, 'private', 'ruby', '*')
-          PDK::Util::Filesystem.glob(ruby_basedir).sort.map { |ruby_dir|
+          PDK::Util::Filesystem.glob(ruby_basedir).sort.map do |ruby_dir|
             version = File.basename(ruby_dir)
-            [version, version.split('.').take(2).concat(['0']).join('.')]
-          }.reverse.to_h
+            [version, version.split('.').take(2).push('0').join('.')]
+          end.reverse.to_h
         end
 
         def default_ruby_version
@@ -71,7 +67,7 @@ module PDK
         end
 
         def latest_ruby_version
-          versions.keys.sort { |a, b| Gem::Version.new(b) <=> Gem::Version.new(a) }.first
+          versions.keys.min { |a, b| Gem::Version.new(b) <=> Gem::Version.new(a) }
         end
 
         def versions
@@ -111,7 +107,7 @@ module PDK
           [
             File.join(PDK::Util.pdk_package_basedir, 'private', 'ruby', ruby_version, 'lib', 'ruby', 'gems', versions[ruby_version]),
             File.join(PDK::Util.package_cachedir, 'ruby', versions[ruby_version]),
-            File.join(PDK::Util.pdk_package_basedir, 'private', 'puppet', 'ruby', versions[ruby_version]),
+            File.join(PDK::Util.pdk_package_basedir, 'private', 'puppet', 'ruby', versions[ruby_version])
           ]
         else
           # This allows the subprocess to find the 'bundler' gem, which isn't
@@ -155,7 +151,7 @@ module PDK
           puppet_specs << spec if spec.name == 'puppet'
         end
 
-        @available_puppet_versions = puppet_specs.map(&:version).sort { |a, b| b <=> a }
+        @available_puppet_versions = puppet_specs.map(&:version).sort.reverse
       end
 
       private

data/lib/pdk/util/template_uri.rb

@@ -3,7 +3,7 @@ require 'pdk'
 module PDK
   module Util
     class TemplateURI
-      SCP_PATTERN = %r{\A(?!\w+://)(?:(?<user>.+?)@)?(?<host>[^:/]+):(?<path>.+)\z}
+      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
@@ -11,8 +11,8 @@ module PDK
 
       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',
+        'macos' => 'file:///opt/puppetlabs/pdk/share/cache/pdk-templates.git',
+        'linux' => 'file:///opt/puppetlabs/pdk/share/cache/pdk-templates.git'
       }.freeze
 
       # XXX Previously
@@ -37,9 +37,10 @@ module PDK
       def initialize(opts_or_uri)
         require 'addressable'
         # If a uri string is passed, skip the valid uri finding code.
-        @uri = if opts_or_uri.is_a?(self.class)
+        @uri = case opts_or_uri
+               when self.class
                  opts_or_uri.uri
-               elsif opts_or_uri.is_a?(String)
+               when String
                  begin
                    uri, ref = opts_or_uri.split('#', 2)
                    if PDK::Util::TemplateURI.packaged_template?(uri)
@@ -48,9 +49,9 @@ module PDK
                      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: {string}' % { string: opts_or_uri }
+                   raise PDK::CLI::FatalError, "PDK::Util::TemplateURI attempted initialization with a non-uri string: #{opts_or_uri}"
                  end
-               elsif opts_or_uri.is_a?(Addressable::URI)
+               when Addressable::URI
                  opts_or_uri.dup
                else
                  PDK::Util::TemplateURI.first_valid_uri(PDK::Util::TemplateURI.templates(opts_or_uri))
@@ -110,7 +111,7 @@ module PDK
         require 'addressable'
 
         if uri.is_a?(Addressable::URI) && uri.fragment
-          human_readable(uri.to_s.chomp('#' + uri.fragment))
+          human_readable(uri.to_s.chomp("##{uri.fragment}"))
         else
           human_readable(uri.to_s)
         end
@@ -149,7 +150,7 @@ module PDK
       #
       # @returns String
       def self.uri_safe(string)
-        url = (Gem.win_platform? && string =~ %r{^[a-zA-Z][\|:]}) ? "/#{string}" : string
+        url = Gem.win_platform? && string =~ /^[a-zA-Z][|:]/ ? "/#{string}" : string
         parse_scp_url(url)
       end
 
@@ -159,7 +160,7 @@ module PDK
       #
       # @returns String
       def self.human_readable(string)
-        (Gem.win_platform? && string =~ %r{^\/[a-zA-Z][\|:]}) ? string[1..-1] : string
+        Gem.win_platform? && string =~ %r{^/[a-zA-Z][|:]} ? string[1..] : string
       end
 
       def self.parse_scp_url(url)
@@ -178,10 +179,7 @@ module PDK
         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 '%{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,
-        }
+        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
@@ -208,22 +206,14 @@ module PDK
         else
           explicit_uri = nil
         end
-        metadata_uri = if PDK::Util.module_root && PDK::Util::Filesystem.file?(File.join(PDK::Util.module_root, 'metadata.json'))
-                         if PDK::Util.module_metadata['template-url']
-                           new(uri_safe(PDK::Util.module_metadata['template-url'])).uri
-                         else
-                           nil
-                         end
-                       else
-                         nil
+        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
-                      else
-                        nil
                       end
         default_uri = default_template_uri.uri
         default_uri.fragment = default_template_ref(default_template_uri)
@@ -257,6 +247,7 @@ module PDK
         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
 
@@ -267,6 +258,7 @@ module PDK
         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
@@ -278,11 +270,7 @@ module PDK
           end
         end
 
-        unless template[:allow_fallback]
-          raise PDK::CLI::FatalError, 'Unable to find a valid template at %{uri}' % {
-            uri: template[:uri].to_s,
-          }
-        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

data/lib/pdk/util/vendored_file.rb

@@ -5,8 +5,7 @@ module PDK
     class VendoredFile
       class DownloadError < StandardError; end
 
-      attr_reader :file_name
-      attr_reader :url
+      attr_reader :file_name, :url
 
       def initialize(file_name, url)
         @file_name = file_name
@@ -44,13 +43,10 @@ module PDK
           Net::HTTPBadResponse,
           Net::HTTPHeaderSyntaxError,
           Net::ProtocolError,
-          Timeout::Error,
+          Timeout::Error
         ]
 
-        PDK.logger.debug '%{file_name} was not found in the cache, downloading it from %{url}.' % {
-          file_name: file_name,
-          url:       url,
-        }
+        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)
@@ -60,20 +56,11 @@ module PDK
         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,
-        }
+        raise DownloadError, format('Unable to download %{url}. Check internet connectivity and try again. %{error}', url: url, error: e)
       end
 
       def package_vendored_path