pdk 1.10.0 → 1.11.0

data/lib/pdk/tests/unit.rb

@@ -7,7 +7,7 @@ module PDK
   module Test
     class Unit
       def self.cmd(tests, opts = {})
-        rake_args = opts.key?(:parallel) ? 'parallel_spec_standalone' : 'spec_standalone'
+        rake_args = opts[:parallel] ? 'parallel_spec_standalone' : 'spec_standalone'
         rake_args += "[#{tests}]" unless tests.nil?
         rake_args
       end
@@ -22,7 +22,7 @@ module PDK
 
         command = PDK::CLI::Exec::Command.new(*argv).tap do |c|
           c.context = :module
-          c.add_spinner(spinner_text)
+          c.add_spinner(spinner_text) if spinner_text
           c.environment = environment
         end
 
@@ -72,23 +72,23 @@ module PDK
 
         environment = { 'CI_SPEC_OPTIONS' => '--format j' }
         environment['PUPPET_GEM_VERSION'] = options[:puppet] if options[:puppet]
-        spinner_msg = options.key?(:parallel) ? _('Running unit tests in parallel.') : _('Running unit tests.')
+        spinner_msg = options[:parallel] ? _('Running unit tests in parallel.') : _('Running unit tests.')
         result = rake(cmd(tests, options), spinner_msg, environment)
 
-        json_result = if options.key?(:parallel)
+        json_result = if options[:parallel]
                         PDK::Util.find_all_json_in(result[:stdout])
                       else
                         PDK::Util.find_first_json_in(result[:stdout])
                       end
 
-        if parallel_with_no_tests?(options.key?(:parallel), json_result, result)
+        if parallel_with_no_tests?(options[:parallel], json_result, result)
           json_result = [{ 'messages' => ['No examples found.'] }]
           result[:exit_code] = 0
         end
 
         raise PDK::CLI::FatalError, _('Unit test output did not contain a valid JSON result: %{output}') % { output: result[:stdout] } if json_result.nil? || json_result.empty?
 
-        json_result = merge_json_results(json_result) if options.key?(:parallel)
+        json_result = merge_json_results(json_result) if options[:parallel]
 
         parse_output(report, json_result, result[:duration])
 
@@ -183,15 +183,13 @@ module PDK
       end
 
       # @return array of { :id, :full_description }
-      def self.list
+      def self.list(options = {})
         PDK::Util::Bundler.ensure_binstubs!('rake')
 
-        command_argv = [File.join(PDK::Util.module_root, 'bin', 'rake'), 'spec_list_json']
-        command_argv.unshift(File.join(PDK::Util::RubyVersion.bin_path, 'ruby.exe')) if Gem.win_platform?
+        environment = {}
+        environment['PUPPET_GEM_VERSION'] = options[:puppet] if options[:puppet]
 
-        list_command = PDK::CLI::Exec::Command.new(*command_argv)
-        list_command.context = :module
-        output = list_command.execute!
+        output = rake('spec_list_json', _('Finding unit tests.'), environment)
 
         rspec_json = PDK::Util.find_first_json_in(output[:stdout])
         raise PDK::CLI::FatalError, _('Failed to find valid JSON in output from rspec: %{output}' % { output: output[:stdout] }) unless rspec_json

data/lib/pdk/util.rb

@@ -106,6 +106,15 @@ module PDK
     end
     module_function :cachedir
 
+    def configdir
+      if Gem.win_platform?
+        File.join(ENV['LOCALAPPDATA'], 'PDK')
+      else
+        File.join(ENV.fetch('XDG_CONFIG_HOME', File.join(Dir.home, '.config')), 'pdk')
+      end
+    end
+    module_function :configdir
+
     # Returns path to the root of the module being worked on.
     #
     # @return [String, nil] Fully qualified base path to module, or nil if

data/lib/pdk/util/bundler.rb

@@ -81,7 +81,7 @@ module PDK
         end
 
         def gemfile_lock
-          return nil if gemfile.nil?
+          return if gemfile.nil?
           @gemfile_lock ||= File.join(File.dirname(gemfile), 'Gemfile.lock')
         end
 
@@ -104,10 +104,6 @@ module PDK
 
           result = cmd.execute!
 
-          unless result[:exit_code].zero?
-            PDK.logger.debug(result.values_at(:stdout, :stderr).join("\n"))
-          end
-
           result[:exit_code].zero?
         end
 
@@ -140,7 +136,7 @@ module PDK
             result = cmd.execute!
 
             unless result[:exit_code].zero?
-              PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n"))
+              PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n")) unless PDK.logger.debug?
               raise PDK::CLI::FatalError, _('Unable to resolve default Gemfile dependencies.')
             end
 
@@ -181,7 +177,7 @@ module PDK
           result = cmd.execute!
 
           unless result[:exit_code].zero?
-            PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n"))
+            PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n")) unless PDK.logger.debug?
             raise PDK::CLI::FatalError, _('Unable to resolve Gemfile dependencies.')
           end
 
@@ -200,7 +196,7 @@ module PDK
           result = cmd.execute!
 
           unless result[:exit_code].zero?
-            PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n"))
+            PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n")) unless PDK.logger.debug?
             raise PDK::CLI::FatalError, _('Unable to install missing Gemfile dependencies.')
           end
 
@@ -215,7 +211,7 @@ module PDK
           result = cmd.execute!
 
           unless result[:exit_code].zero?
-            PDK.logger.fatal(_("Failed to generate binstubs for '%{gems}':\n%{output}") % { gems: gems.join(' '), output: result.values_at(:stdout, :stderr).join("\n") })
+            PDK.logger.fatal(_("Failed to generate binstubs for '%{gems}':\n%{output}") % { gems: gems.join(' '), output: result.values_at(:stdout, :stderr).join("\n") }) unless PDK.logger.debug?
             raise PDK::CLI::FatalError, _('Unable to install requested binstubs.')
           end
 

data/lib/pdk/util/filesystem.rb

@@ -13,6 +13,43 @@ module PDK
         File.open(path, 'wb') { |f| f.write(content) }
       end
       module_function :write_file
+
+      def read_file(file, nil_on_error: false)
+        File.read(file)
+      rescue => e
+        raise e unless nil_on_error
+        nil
+      end
+      module_function :read_file
+
+      #:nocov:
+      # These methods just wrap core Ruby functionality and
+      # can be ignored for code coverage
+      def directory?(*args)
+        File.directory?(*args)
+      end
+      module_function :directory?
+
+      def file?(*args)
+        File.file?(*args)
+      end
+      module_function :file?
+
+      def expand_path(*args)
+        File.expand_path(*args)
+      end
+      module_function :expand_path
+
+      def glob(*args)
+        Dir.glob(*args)
+      end
+      module_function :glob
+
+      def fnmatch(*args)
+        File.fnmatch(*args)
+      end
+      module_function :fnmatch
+      #:nocov:
     end
   end
 end

data/lib/pdk/util/puppet_version.rb

@@ -138,7 +138,7 @@ module PDK
 
           unless metadata_file
             PDK.logger.warn _('Unable to determine Puppet version for module: no metadata.json present in module.')
-            return nil
+            return
           end
 
           metadata = PDK::Module::Metadata.from_file(metadata_file)

data/lib/pdk/util/ruby_version.rb

@@ -8,6 +8,8 @@ module PDK
 
         def_delegators :instance, :gem_path, :gem_paths_raw, :gem_home, :available_puppet_versions, :bin_path
 
+        # TODO: resolve this
+        # rubocop:disable Lint/DuplicateMethods
         attr_reader :instance
 
         def instance(version = nil)
@@ -21,6 +23,7 @@ module PDK
           end
           @instance[active_ruby_version]
         end
+        # rubocop:enable Lint/DuplicateMethods
 
         def active_ruby_version
           @active_ruby_version || default_ruby_version
@@ -45,12 +48,19 @@ module PDK
         end
 
         def default_ruby_version
-          # For now, the packaged versions will be using default of 2.4.5
-          # FIXME: make this dynamic
-          return '2.4.5' if PDK::Util.package_install?
-
-          # TODO: may not be a safe assumption that highest available version should be default
-          latest_ruby_version
+          @default_ruby_version ||= if PDK::Util.package_install?
+                                      # Default to the ruby that supports the latest puppet gem. If you wish to default to a
+                                      # specific Puppet Gem version use the following example;
+                                      #
+                                      # PDK::Util::PuppetVersion.find_gem_for('5.5.10')[:ruby_version]
+                                      #
+                                      PDK::Util::PuppetVersion.latest_available[:ruby_version]
+                                    else
+                                      # TODO: may not be a safe assumption that highest available version should be default
+                                      # WARNING Do NOT use PDK::Util::PuppetVersion.*** methods as it can recurse into this
+                                      # method and cause Stack Level Too Deep errors.
+                                      latest_ruby_version
+                                    end
         end
 
         def latest_ruby_version

data/lib/pdk/util/template_uri.rb

@@ -5,6 +5,15 @@ module PDK
     class TemplateURI
       SCP_PATTERN = %r{\A(?!\w+://)(?:(?<user>.+?)@)?(?<host>[^:/]+):(?<path>.+)\z}
 
+      PACKAGED_TEMPLATE_KEYWORD = 'pdk-default'.freeze
+      DEPRECATED_TEMPLATE_URL = 'https://github.com/puppetlabs/pdk-module-template'.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
@@ -26,9 +35,16 @@ module PDK
       #
       def initialize(opts_or_uri)
         # If a uri string is passed, skip the valid uri finding code.
-        @uri = if opts_or_uri.is_a?(String) || opts_or_uri.is_a?(self.class)
+        @uri = if opts_or_uri.is_a?(self.class)
+                 opts_or_uri.uri
+               elsif opts_or_uri.is_a?(String)
                  begin
-                   Addressable::URI.parse(opts_or_uri)
+                   uri, ref = opts_or_uri.split('#', 2)
+                   if self.class.packaged_template?(uri)
+                     self.class.default_template_uri(ref).uri
+                   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: {string}') % { string: opts_or_uri }
                  end
@@ -48,7 +64,11 @@ module PDK
       #
       # @returns String
       def metadata_format
-        self.class.human_readable(@uri.to_s)
+        if self.class.packaged_template?(git_remote)
+          self.class.human_readable("pdk-default##{git_ref}")
+        else
+          self.class.human_readable(@uri.to_s)
+        end
       end
       alias to_s metadata_format
       alias to_str metadata_format
@@ -76,11 +96,7 @@ module PDK
 
       # @returns String
       def git_ref
-        if @uri.fragment
-          @uri.fragment
-        else
-          self.class.default_template_ref
-        end
+        @uri.fragment || self.class.default_template_ref(self)
       end
 
       def git_ref=(ref)
@@ -88,11 +104,11 @@ module PDK
       end
 
       # @returns PDK::Util::TemplateURI
-      def self.default_template_uri
+      def self.default_template_uri(ref = nil)
         if PDK::Util.package_install?
-          PDK::Util::TemplateURI.new(Addressable::URI.new(scheme: 'file', host: '', path: File.join(PDK::Util.package_cachedir, 'pdk-templates.git')))
+          PDK::Util::TemplateURI.new(Addressable::URI.new(scheme: 'file', host: '', path: File.join(PDK::Util.package_cachedir, 'pdk-templates.git'), fragment: ref))
         else
-          PDK::Util::TemplateURI.new('https://github.com/puppetlabs/pdk-templates')
+          PDK::Util::TemplateURI.new(Addressable::URI.new(scheme: 'https', host: 'github.com', path: '/puppetlabs/pdk-templates', fragment: ref))
         end
       end
 
@@ -106,11 +122,12 @@ module PDK
 
       # `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 but are not handled here. Should they be?
+      # either and so are subsequently converted to ssh:// URIs.
       #
       # @returns String
       def self.uri_safe(string)
-        (Gem.win_platform? && string =~ %r{^[a-zA-Z][\|:]}) ? "/#{string}" : string
+        url = (Gem.win_platform? && string =~ %r{^[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
@@ -122,6 +139,27 @@ module PDK
         (Gem.win_platform? && string =~ %r{^\/[a-zA-Z][\|:]}) ? string[1..-1] : string
       end
 
+      def self.parse_scp_url(url)
+        # 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 _('%{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
@@ -136,42 +174,29 @@ module PDK
         # 1. Get the CLI, metadata (or answers if no metadata), and default URIs
         # 2. Construct the hash
         if explicit_url
-          # 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 = explicit_url.match(SCP_PATTERN)
-          if Pathname.new(uri_safe(explicit_url)).relative? && scp_url
-            explicit_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: explicit_url,
-              rfc_uri: explicit_uri.to_s,
-            }
-          end
-          explicit_uri ||= Addressable::URI.parse(uri_safe(explicit_url))
-          explicit_uri.fragment = explicit_ref || default_template_ref
+          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 && File.file?(File.join(PDK::Util.module_root, 'metadata.json'))
-                         Addressable::URI.parse(uri_safe(PDK::Util.module_metadata['template-url']))
+                         if PDK::Util.module_metadata['template-url']
+                           new(uri_safe(PDK::Util.module_metadata['template-url'])).uri
+                         else
+                           nil
+                         end
                        else
                          nil
                        end
-        answers_uri = if PDK.answers['template-url'] == 'https://github.com/puppetlabs/pdk-module-template'
-                        # use the new github template-url if it is still the old one.
+        answers_uri = if [PACKAGED_TEMPLATE_KEYWORD, DEPRECATED_TEMPLATE_URL].include?(PDK.answers['template-url'])
                         Addressable::URI.parse(default_template_uri)
                       elsif PDK.answers['template-url']
-                        Addressable::URI.parse(uri_safe(PDK.answers['template-url']))
+                        new(uri_safe(PDK.answers['template-url'])).uri
                       else
                         nil
                       end
-        default_uri = Addressable::URI.parse(default_template_uri)
-        default_uri.fragment = default_template_ref
+        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
@@ -182,12 +207,12 @@ module PDK
       end
 
       # @returns String
-      def self.default_template_ref
-        if PDK::Util.development_mode?
-          'master'
-        else
-          PDK::TEMPLATE_REF
-        end
+      def self.default_template_ref(uri = nil)
+        return 'master' 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 : 'master'
       end
 
       # @returns Addressable::URI
@@ -226,6 +251,10 @@ module PDK
 
         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/version.rb

@@ -27,7 +27,7 @@ module PDK
       def self.git_ref
         source_git_dir = File.join(File.expand_path('../../..', File.dirname(__FILE__)), '.git')
 
-        return nil unless File.directory?(source_git_dir)
+        return unless File.directory?(source_git_dir)
 
         PDK::Util::Git.describe(source_git_dir)
       end

data/lib/pdk/util/windows.rb

@@ -1,6 +1,7 @@
 module PDK
   module Util
     module Windows
+      WIN32_FALSE = 0
       module File; end
 
       if Gem.win_platform?