pdk 1.9.0 → 3.2.0

data/lib/pdk/util/puppet_version.rb

@@ -1,5 +1,6 @@
-require 'pdk/util'
-require 'pdk/util/git'
+require 'pdk'
+require 'json'
+require 'forwardable'
 
 module PDK
   module Util
@@ -18,45 +19,55 @@ module PDK
 
       PE_VERSIONS_URL = 'https://forgeapi.puppet.com/private/versions/pe'.freeze
       DEFAULT_PUPPET_DEV_URL = 'https://github.com/puppetlabs/puppet'.freeze
-      DEFAULT_PUPPET_DEV_BRANCH = 'master'.freeze
+      DEFAULT_PUPPET_DEV_BRANCH = 'main'.freeze
 
       def puppet_dev_env
+        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
 
       def puppet_dev_path
+        require 'pdk/util'
+
         File.join(PDK::Util.cachedir, 'src', 'puppet')
       end
 
       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
 
-      def fetch_puppet_dev
+      def puppet_dev_fetched?
+        !@puppet_dev_fetched.nil?
+      end
+
+      def fetch_puppet_dev(options = {})
+        return if options[:run] == :once && puppet_dev_fetched?
+
+        require 'pdk/util/git'
+
         # Check if the source is cloned and is a readable git repo
         unless PDK::Util::Git.remote_repo? puppet_dev_path
           # Check if the path has something in it already. Delete it and prepare for clone if so.
-          if File.exist? puppet_dev_path
-            File.delete(puppet_dev_path) if File.file? puppet_dev_path
-            FileUtils.rm_rf(puppet_dev_path) if File.directory? puppet_dev_path
+          if PDK::Util::Filesystem.exist? puppet_dev_path
+            PDK::Util::Filesystem.delete(puppet_dev_path) if PDK::Util::Filesystem.file? puppet_dev_path
+            PDK::Util::Filesystem.rm_rf(puppet_dev_path) if PDK::Util::Filesystem.directory? puppet_dev_path
           end
 
-          FileUtils.mkdir_p puppet_dev_path
+          PDK::Util::Filesystem.mkdir_p puppet_dev_path
           clone_result = PDK::Util::Git.git('clone', DEFAULT_PUPPET_DEV_URL, puppet_dev_path)
           return if clone_result[:exit_code].zero?
 
           PDK.logger.error clone_result[:stdout]
           PDK.logger.error clone_result[:stderr]
-          raise PDK::CLI::FatalError, _("Unable to clone git repository at '%{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
@@ -65,16 +76,18 @@ 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
-        reset_result = PDK::Util::Git.git('-C', puppet_dev_path, 'reset', '--hard', 'origin/master')
+        reset_result = PDK::Util::Git.git('-C', puppet_dev_path, 'reset', '--hard', "origin/#{DEFAULT_PUPPET_DEV_BRANCH}")
+
+        @puppet_dev_fetched = true
         return if reset_result[:exit_code].zero?
 
         PDK.logger.error reset_result[:stdout]
         PDK.logger.error reset_result[:stderr]
-        raise PDK::CLI::FatalError, _("Unable to update git repository at '%{cachedir}'.") % { repo: 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)
@@ -91,21 +104,14 @@ module PDK
         requirement_string = version.approximate_recommendation
         requirement_string += '.0' unless version.segments.length == 1
         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
@@ -114,31 +120,33 @@ module PDK
       def from_pe_version(version_str)
         version = parse_specified_version(version_str)
 
-        gem_version = pe_version_map.find do |version_map|
-          version_map[:requirement].satisfied_by?(version)
-        end
+        # Due to the issue with concurrent ruby in older puppet gems
+        # we are locking the pe to puppet version mapping to the latest
+        # puppet version that is compatible with the pe version.
+        safe_versions = {
+          2023 => '7.23.0',
+          2021 => '7.23.0',
+          2019 => '6.29.0'
+        }
 
-        if gem_version.nil?
-          raise ArgumentError, _('Unable to map Puppet Enterprise version %{pe_version} to a Puppet version.') % {
-            pe_version: version_str,
-          }
-        end
+        gem_version = safe_versions[version.segments[0]]
+        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[: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[:gem_version])
+        find_gem_for(gem_version)
       end
 
       def from_module_metadata(metadata = nil)
+        require 'pdk/module/metadata'
+        require 'pdk/util'
+
         if metadata.nil?
           metadata_file = PDK::Util.find_upwards('metadata.json')
 
           unless metadata_file
-            PDK.logger.warn _('Unable to determine Puppet version for module: no metadata.json present in module.')
-            return nil
+            PDK.logger.warn 'Unable to determine Puppet version for module: no metadata.json present in module.'
+            return
           end
 
           metadata = PDK::Module::Metadata.from_file(metadata_file)
@@ -149,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
@@ -163,59 +171,27 @@ 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
-        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
-        return @rubygems_puppet_versions unless @rubygems_puppet_versions.nil?
-
-        fetcher = Gem::SpecFetcher.fetcher
-        puppet_tuples = fetcher.detect(:released) do |spec_tuple|
-          spec_tuple.name == 'puppet' && Gem::Platform.match(spec_tuple.platform)
+        @rubygems_puppet_versions ||= begin
+          fetcher = Gem::SpecFetcher.fetcher
+          puppet_tuples = fetcher.detect(:released) do |spec_tuple|
+            spec_tuple.name == 'puppet' && Gem::Platform.match(spec_tuple.platform)
+          end
+          puppet_versions = puppet_tuples.map { |name, _| name.version }.uniq
+          puppet_versions.sort.reverse
         end
-        puppet_versions = puppet_tuples.map { |name, _| name.version }.uniq
-        @rubygems_puppet_versions = puppet_versions.sort { |a, b| b <=> a }
       end
 
       def find_gem(requirement)
+        require 'pdk/util'
+
         if PDK::Util.package_install?
           find_in_package_cache(requirement)
         else
@@ -224,12 +200,20 @@ module PDK
       end
 
       def find_in_rubygems(requirement)
+        require 'pdk/util/ruby_version'
+
         version = rubygems_puppet_versions.find { |r| requirement.satisfied_by?(r) }
         version.nil? ? nil : { gem_version: version, ruby_version: PDK::Util::RubyVersion.default_ruby_version }
       end
 
+      # Finds the specified requirement in the package cache.
+      #
+      # @param requirement [Gem::Requirement] The requirement to search for.
+      # @return [Hash] A hash containing the gem version and ruby version if found, or nil if not found.
       def find_in_package_cache(requirement)
-        PDK::Util::RubyVersion.versions.each do |ruby_version, _|
+        require 'pdk/util/ruby_version'
+
+        PDK::Util::RubyVersion.versions.each_key do |ruby_version|
           PDK::Util::RubyVersion.use(ruby_version)
           version = PDK::Util::RubyVersion.available_puppet_versions.find { |r| requirement.satisfied_by?(r) }
           return { gem_version: version, ruby_version: ruby_version } unless version.nil?

data/lib/pdk/util/ruby_version.rb

@@ -1,4 +1,5 @@
-require 'pdk/util'
+require 'pdk'
+require 'forwardable'
 
 module PDK
   module Util
@@ -8,6 +9,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,43 +24,55 @@ module PDK
           end
           @instance[active_ruby_version]
         end
+        # rubocop:enable Lint/DuplicateMethods
 
         def active_ruby_version
           @active_ruby_version || default_ruby_version
         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', '*')
-          Dir[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
-          # 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
+          require 'pdk/util'
+          require 'pdk/util/puppet_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]
+                                      #
+                                      # For using the latest puppet gem:
+                                      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
-          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
+          require 'pdk/util'
+
           @versions ||= if PDK::Util.package_install?
                           scan_for_packaged_rubies
                         else
@@ -73,6 +88,8 @@ module PDK
       end
 
       def bin_path
+        require 'pdk/util'
+
         if PDK::Util.package_install?
           File.join(PDK::Util.pdk_package_basedir, 'private', 'ruby', ruby_version, 'bin')
         else
@@ -81,6 +98,8 @@ module PDK
       end
 
       def gem_paths_raw
+        require 'pdk/util'
+
         if PDK::Util.package_install?
           # Subprocesses use their own set of gems which are managed by pdk or
           # installed with the package. We also include the separate gem path
@@ -88,14 +107,12 @@ 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
           # in GEM_HOME for gem installs.
-          # TODO: There must be a better way to do this than shelling out to
-          # gem... Perhaps can be replaced with "Gem.path"?
-          [File.absolute_path(File.join(`gem which bundler`, '..', '..', '..', '..'))]
+          [File.absolute_path(File.join(bundler_basedir, '..', '..', '..'))]
         end
       end
 
@@ -104,6 +121,9 @@ module PDK
       end
 
       def gem_home
+        require 'pdk/util'
+
+        # TODO: bundle install --path is deprecated
         # `bundle install --path` ignores all "system" installed gems and
         # causes unnecessary package installs. `bundle install` (without
         # --path) installs into GEM_HOME, which by default is non-user
@@ -118,10 +138,10 @@ module PDK
       def available_puppet_versions
         return @available_puppet_versions unless @available_puppet_versions.nil?
 
-        puppet_spec_files = Dir[File.join(gem_home, 'specifications', '**', 'puppet*.gemspec')]
+        puppet_spec_files = PDK::Util::Filesystem.glob(File.join(gem_home, 'specifications', '**', 'puppet*.gemspec'))
 
         gem_path.split(File::PATH_SEPARATOR).each do |path|
-          puppet_spec_files += Dir[File.join(path, 'specifications', '**', 'puppet*.gemspec')]
+          puppet_spec_files += PDK::Util::Filesystem.glob(File.join(path, 'specifications', '**', 'puppet*.gemspec'))
         end
 
         puppet_specs = []
@@ -131,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
@@ -143,6 +163,10 @@ module PDK
       def versions
         self.class.versions
       end
+
+      def bundler_basedir
+        Gem::Specification.latest_specs.find { |spec| spec.name.eql?('bundler') }.base_dir
+      end
     end
   end
 end