pdk 1.9.0 → 3.2.0

data/lib/pdk/tests/unit.rb

@@ -1,28 +1,45 @@
 require 'pdk'
-require 'pdk/cli/exec'
-require 'pdk/util/bundler'
-require 'json'
 
 module PDK
   module Test
     class Unit
       def self.cmd(tests, opts = {})
-        rake_args = opts.key?(:parallel) ? 'parallel_spec_standalone' : 'spec_standalone'
-        rake_args += "[#{tests}]" unless tests.nil?
+        rake_args = opts[:parallel] ? 'parallel_spec_standalone' : 'spec_standalone'
+        rake_args += "[#{tests}]" unless tests.nil? || tests.empty?
         rake_args
       end
 
       def self.rake_bin
+        require 'pdk/util'
+
         @rake ||= File.join(PDK::Util.module_root, 'bin', 'rake')
       end
 
-      def self.rake(task, spinner_text, environment = {})
+      def self.cmd_with_args(task)
+        require 'pdk/util/ruby_version'
+
         argv = [rake_bin, task]
         argv.unshift(File.join(PDK::Util::RubyVersion.bin_path, 'ruby.exe')) if Gem.win_platform?
+        argv
+      end
+
+      def self.rake(task, spinner_text, environment = {})
+        require 'pdk/cli/exec/command'
+
+        command = PDK::CLI::Exec::Command.new(*cmd_with_args(task)).tap do |c|
+          c.context = :module
+          c.add_spinner(spinner_text) if spinner_text
+          c.environment = environment
+        end
+
+        command.execute!
+      end
+
+      def self.interactive_rake(task, environment)
+        require 'pdk/cli/exec/interactive_command'
 
-        command = PDK::CLI::Exec::Command.new(*argv).tap do |c|
+        command = PDK::CLI::Exec::InteractiveCommand.new(*cmd_with_args(task)).tap do |c|
           c.context = :module
-          c.add_spinner(spinner_text)
           c.environment = environment
         end
 
@@ -31,64 +48,94 @@ module PDK
 
       def self.parallel_with_no_tests?(ran_in_parallel, json_result, result)
         ran_in_parallel && json_result.empty? &&
-          ((!result[:exit_code].zero? && result[:stderr].strip =~ %r{Pass files or folders to run$}) ||
-           result[:stderr].strip =~ %r{No files for parallel_spec to run against$})
+          ((!result[:exit_code].zero? && result[:stderr].strip =~ /Pass files or folders to run$/) ||
+           result[:stderr].strip =~ /No files for parallel_spec to run against$/)
       end
 
       def self.print_failure(result, exception)
         $stderr.puts ''
-        result[:stdout].each_line { |line| $stderr.puts line.rstrip } unless result[:stdout].nil?
-        result[:stderr].each_line { |line| $stderr.puts line.rstrip } unless result[:stderr].nil?
+        result[:stdout]&.each_line { |line| $stderr.puts line.rstrip }
+        result[:stderr]&.each_line { |line| $stderr.puts line.rstrip }
         $stderr.puts ''
         raise PDK::CLI::FatalError, exception
       end
 
       def self.tear_down
-        result = rake('spec_clean', _('Cleaning up after running unit tests.'))
+        result = rake('spec_clean', 'Cleaning up after running unit tests.')
 
         return if result[:exit_code].zero?
 
-        PDK.logger.error(_('The spec_clean rake task failed with the following error(s):'))
-        print_failure(result, _('Failed to clean up after running unit tests'))
+        PDK.logger.error('The spec_clean rake task failed with the following error(s):')
+        print_failure(result, 'Failed to clean up after running unit tests')
       end
 
       def self.setup
-        result = rake('spec_prep', _('Preparing to run the unit tests.'))
+        result = rake('spec_prep', 'Preparing to run the unit tests.')
 
         return if result[:exit_code].zero?
 
         tear_down
 
-        PDK.logger.error(_('The spec_prep rake task failed with the following error(s):'))
-        print_failure(result, _('Failed to prepare to run the unit tests.'))
+        PDK.logger.error('The spec_prep rake task failed with the following error(s):')
+        print_failure(result, 'Failed to prepare to run the unit tests.')
       end
 
       def self.invoke(report, options = {})
+        require 'pdk/util'
+        require 'pdk/util/bundler'
+
         PDK::Util::Bundler.ensure_binstubs!('rake', 'rspec-core')
 
         setup
 
-        tests = options.fetch(:tests)
+        tests = options[:tests]
+        # Due to how rake handles paths in the command line options, any backslashed path (Windows platforms) needs to be converted
+        # to forward slash. We can't use File.expand_path as the files aren't guaranteed to be on-disk
+        #
+        # Ref - https://github.com/puppetlabs/pdk/issues/828
+        tests = tests.tr('\\', '/') unless tests.nil?
 
-        environment = { 'CI_SPEC_OPTIONS' => '--format j' }
+        environment = {}
         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.'
+
+        if options[:interactive]
+          environment['CI_SPEC_OPTIONS'] = if options[:verbose]
+                                             '--format documentation'
+                                           else
+                                             '--format progress'
+                                           end
+          result = interactive_rake(cmd(tests, options), environment)
+          return result[:exit_code]
+        end
+
+        # Run interactive_rake for documentation output when utilising verbose option.
+        if (options[:verbose]) && (options[:format])
+          environment['CI_SPEC_OPTIONS'] = '--format documentation'
+          result = interactive_rake(cmd(tests, options), environment)
+          # Caveat: Report will not be written to format option(s) file(s) when there are event failures.
+          return result[:exit_code] unless (result[:exit_code]).zero?
+
+          spinner_msg = "Exporting unit tests -> #{options[:format]}"
+        end
+
+        environment['CI_SPEC_OPTIONS'] = '--format j'
         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?
+        raise PDK::CLI::FatalError, format('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])
 
@@ -99,38 +146,38 @@ module PDK
 
       def self.parse_output(report, json_data, duration)
         # Output messages to stderr.
-        json_data['messages'] && json_data['messages'].each { |msg| $stderr.puts msg }
+        json_data['messages']&.each { |msg| $stderr.puts msg }
 
         example_results = {
           # Only possibilities are passed, failed, pending:
-          # https://github.com/rspec/rspec-core/blob/master/lib/rspec/core/example.rb#L548
+          # https://github.com/rspec/rspec-core/blob/main/lib/rspec/core/example.rb#L548
           'passed' => [],
           'failed' => [],
-          'pending' => [],
+          'pending' => []
         }
 
-        json_data['examples'] && json_data['examples'].each do |ex|
+        json_data['examples']&.each do |ex|
           example_results[ex['status']] << ex if example_results.key?(ex['status'])
         end
 
         example_results.each do |result, examples|
           # Translate rspec example results to JUnit XML testcase results
-          state = case result
-                  when 'passed' then :passed
-                  when 'failed' then :failure
-                  when 'pending' then :skipped
-                  end
+          state_map = {
+            'passed' => :passed,
+            'failed' => :failure,
+            'pending' => :skipped
+          }
 
           examples.each do |ex|
             report.add_event(
               source: 'rspec',
-              state: state,
+              state: state_map[result],
               file: ex['file_path'],
               line: ex['line_number'],
               test: ex['full_description'],
               severity: ex['status'],
               message: ex['pending_message'] || (ex['exception'] && ex['exception']['message']) || nil,
-              trace: (ex['exception'] && ex['exception']['backtrace']) || nil,
+              trace: (ex['exception'] && ex['exception']['backtrace']) || nil
             )
           end
         end
@@ -138,21 +185,20 @@ module PDK
         return unless json_data['summary']
 
         # TODO: standardize summary output
-        $stderr.puts '  ' << _('Evaluated %{total} tests in %{duration} seconds: %{failures} failures, %{pending} pending.') % {
-          total: json_data['summary']['example_count'],
-          duration: duration,
-          failures: json_data['summary']['failure_count'],
-          pending: json_data['summary']['pending_count'],
-        }
+        $stderr.puts '  ' << (format('Evaluated %{total} tests in %{duration} seconds: %{failures} failures, %{pending} pending.', total: json_data['summary']['example_count'], duration: duration,
+                                                                                                                                   failures: json_data['summary']['failure_count'], pending: json_data['summary']['pending_count'])) # rubocop:disable Layout/LineLength
       end
 
       def self.merge_json_results(json_data)
+        require 'set'
+
         merged_json_result = {}
 
         # Merge messages
         message_set = Set.new
         json_data.each do |json|
           next unless json['messages']
+
           message_set |= json['messages']
         end
         merged_json_result['messages'] = message_set.to_a
@@ -161,6 +207,7 @@ module PDK
         all_examples = []
         json_data.each do |json|
           next unless json['examples']
+
           all_examples.concat json['examples']
         end
         merged_json_result['examples'] = all_examples
@@ -169,10 +216,11 @@ module PDK
         summary_hash = {
           'example_count' => 0,
           'failure_count' => 0,
-          'pending_count' => 0,
+          'pending_count' => 0
         }
         json_data.each do |json|
           next unless json['summary']
+
           summary_hash['example_count'] += json['summary']['example_count']
           summary_hash['failure_count'] += json['summary']['failure_count']
           summary_hash['pending_count'] += json['summary']['pending_count']
@@ -183,23 +231,25 @@ module PDK
       end
 
       # @return array of { :id, :full_description }
-      def self.list
+      def self.list(options = {})
+        require 'pdk/util'
+        require 'pdk/util/bundler'
+
         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
+        raise PDK::CLI::FatalError, format('Failed to find valid JSON in output from rspec: %{output}', output: output[:stdout]) unless rspec_json
+
         if rspec_json['examples'].empty?
           rspec_message = rspec_json['messages'][0]
           return [] if rspec_message == 'No examples found.'
 
-          raise PDK::CLI::FatalError, _('Unable to enumerate examples. rspec reported: %{message}' % { message: rspec_message })
+          raise PDK::CLI::FatalError, format('Unable to enumerate examples. rspec reported: %{message}', message: rspec_message)
         else
           examples = []
           rspec_json['examples'].each do |example|

data/lib/pdk/util/bundler.rb

@@ -1,27 +1,23 @@
-require 'bundler'
-require 'digest'
-require 'fileutils'
-require 'pdk/util'
-require 'pdk/cli/exec'
+require 'pdk'
 
 module PDK
   module Util
     module Bundler
-      class BundleHelper; end
+      # class BundleHelper; end
 
-      def self.ensure_bundle!(gem_overrides = nil)
+      def self.ensure_bundle!(gem_overrides = {})
         bundle = BundleHelper.new
 
         # This will default ensure_bundle! to re-resolving everything to latest
         gem_overrides ||= { puppet: nil, hiera: nil, facter: nil }
 
         if already_bundled?(bundle.gemfile, gem_overrides)
-          PDK.logger.debug(_('Bundler managed gems already up to date.'))
+          PDK.logger.debug('Bundler managed gems already up to date.')
           return
         end
 
         unless bundle.gemfile?
-          PDK.logger.debug(_("No Gemfile found in '%{cwd}'. Skipping bundler management.") % { cwd: Dir.pwd })
+          PDK.logger.debug(format("No Gemfile found in '%{cwd}'. Skipping bundler management.", cwd: Dir.pwd))
           return
         end
 
@@ -36,11 +32,11 @@ module PDK
           original_lockfile = bundle.gemfile_lock
           temp_lockfile = "#{original_lockfile}.tmp"
 
-          FileUtils.mv(original_lockfile, temp_lockfile)
+          PDK::Util::Filesystem.mv(original_lockfile, temp_lockfile)
 
           all_deps_available = bundle.installed?(gem_overrides)
         ensure
-          FileUtils.mv(temp_lockfile, original_lockfile, force: true)
+          PDK::Util::Filesystem.mv(temp_lockfile, original_lockfile, force: true)
         end
 
         bundle.update_lock!(with: gem_overrides, local: all_deps_available)
@@ -48,9 +44,7 @@ module PDK
         # If there are missing dependencies after updating the lockfile, let `bundle install`
         # go out and get them. If the specified puppet gem version points to a remote location
         # or local filepath, then run bundle install as well.
-        if !bundle.installed? || (gem_overrides[:puppet] && gem_overrides[:puppet].start_with?('file://', 'git://', 'https://'))
-          bundle.install!(gem_overrides)
-        end
+        bundle.install!(gem_overrides) if !bundle.installed?(gem_overrides) || gem_overrides[:puppet]&.start_with?('file://', 'git://', 'https://')
 
         mark_as_bundled!(bundle.gemfile, gem_overrides)
       end
@@ -70,6 +64,8 @@ module PDK
       end
 
       def self.bundle_cache_key(gemfile, gem_overrides)
+        require 'digest'
+
         override_sig = (gem_overrides || {}).sort_by { |gem, _| gem.to_s }.to_s
         Digest::MD5.hexdigest(gemfile.to_s + override_sig)
       end
@@ -77,11 +73,13 @@ module PDK
 
       class BundleHelper
         def gemfile
+          require 'pdk/util'
           @gemfile ||= PDK::Util.find_upwards('Gemfile')
         end
 
         def gemfile_lock
-          return nil if gemfile.nil?
+          return if gemfile.nil?
+
           @gemfile_lock ||= File.join(File.dirname(gemfile), 'Gemfile.lock')
         end
 
@@ -90,11 +88,11 @@ module PDK
         end
 
         def locked?
-          !gemfile_lock.nil? && File.file?(gemfile_lock)
+          !gemfile_lock.nil? && PDK::Util::Filesystem.file?(gemfile_lock)
         end
 
         def installed?(gem_overrides = {})
-          PDK.logger.debug(_('Checking for missing Gemfile dependencies.'))
+          PDK.logger.debug('Checking for missing Gemfile dependencies.')
 
           argv = ['check', "--gemfile=#{gemfile}", '--dry-run']
 
@@ -104,44 +102,41 @@ 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
 
         def lock!
+          require 'pdk/util'
+          require 'pdk/util/ruby_version'
+
           if PDK::Util.package_install?
             # In packaged installs, use vendored Gemfile.lock as a starting point.
             # Subsequent 'bundle install' will still pick up any new dependencies.
             vendored_lockfiles = [
               File.join(PDK::Util.package_cachedir, "Gemfile-#{PDK::Util::RubyVersion.active_ruby_version}.lock"),
-              File.join(PDK::Util.package_cachedir, 'Gemfile.lock'),
+              File.join(PDK::Util.package_cachedir, 'Gemfile.lock')
             ]
 
-            vendored_gemfile_lock = vendored_lockfiles.find { |lockfile| File.exist?(lockfile) }
-
-            unless vendored_gemfile_lock
-              raise PDK::CLI::FatalError, _('Vendored Gemfile.lock (%{source}) not found.') % {
-                source: vendored_gemfile_lock,
-              }
+            vendored_gemfile_lock = vendored_lockfiles.find do |lockfile|
+              PDK::Util::Filesystem.exist?(lockfile)
             end
 
-            PDK.logger.debug(_('Using vendored Gemfile.lock from %{source}.') % { source: vendored_gemfile_lock })
-            FileUtils.cp(vendored_gemfile_lock, File.join(PDK::Util.module_root, 'Gemfile.lock'))
+            raise PDK::CLI::FatalError, format('Vendored Gemfile.lock (%{source}) not found.', source: vendored_gemfile_lock) unless vendored_gemfile_lock
+
+            PDK.logger.debug(format('Using vendored Gemfile.lock from %{source}.', source: vendored_gemfile_lock))
+            PDK::Util::Filesystem.cp(vendored_gemfile_lock, File.join(PDK::Util.module_root, 'Gemfile.lock'))
           else
             argv = ['lock']
 
             cmd = bundle_command(*argv).tap do |c|
-              c.add_spinner(_('Resolving default Gemfile dependencies.'))
+              c.add_spinner('Resolving default Gemfile dependencies.')
             end
 
             result = cmd.execute!
 
             unless result[:exit_code].zero?
-              PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n"))
-              raise PDK::CLI::FatalError, _('Unable to resolve default Gemfile dependencies.')
+              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
 
             # After initial lockfile generation, re-resolve json gem to built-in
@@ -154,7 +149,7 @@ module PDK
         end
 
         def update_lock!(options = {})
-          PDK.logger.debug(_('Updating Gemfile dependencies.'))
+          PDK.logger.debug('Updating Gemfile dependencies.')
 
           argv = ['lock', "--lockfile=#{gemfile_lock}", '--update']
 
@@ -181,42 +176,46 @@ module PDK
           result = cmd.execute!
 
           unless result[:exit_code].zero?
-            PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n"))
-            raise PDK::CLI::FatalError, _('Unable to resolve Gemfile dependencies.')
+            PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n")) unless PDK.logger.debug?
+            raise PDK::CLI::FatalError, 'Unable to resolve Gemfile dependencies.'
           end
 
           true
         end
 
         def install!(gem_overrides = {})
+          require 'pdk/util/ruby_version'
+
           argv = ['install', "--gemfile=#{gemfile}"]
           argv << '-j4' unless Gem.win_platform? && Gem::Version.new(PDK::Util::RubyVersion.active_ruby_version) < Gem::Version.new('2.3.5')
 
           cmd = bundle_command(*argv).tap do |c|
-            c.add_spinner(_('Installing missing Gemfile dependencies.'))
+            c.add_spinner('Installing missing Gemfile dependencies.')
             c.update_environment(gemfile_env(gem_overrides)) unless gem_overrides.empty?
           end
 
           result = cmd.execute!
 
           unless result[:exit_code].zero?
-            PDK.logger.fatal(result.values_at(:stdout, :stderr).join("\n"))
-            raise PDK::CLI::FatalError, _('Unable to install missing Gemfile dependencies.')
+            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
 
           true
         end
 
         def binstubs!(gems)
+          raise PDK::CLI::FatalError, 'Unable to install requested binstubs as the Gemfile is missing' if gemfile.nil?
+
           binstub_dir = File.join(File.dirname(gemfile), 'bin')
-          return true if gems.all? { |gem| File.file?(File.join(binstub_dir, gem)) }
+          return true if gems.all? { |gem| PDK::Util::Filesystem.file?(File.join(binstub_dir, gem)) }
 
           cmd = bundle_command('binstubs', *gems, '--force')
           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") })
-            raise PDK::CLI::FatalError, _('Unable to install requested binstubs.')
+            PDK.logger.fatal(format("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
 
           true
@@ -243,6 +242,9 @@ module PDK
         end
 
         def bundle_command(*args)
+          require 'pdk/cli/exec'
+          require 'pdk/cli/exec/command'
+
           PDK::CLI::Exec::Command.new(PDK::CLI::Exec.bundle_bin, *args).tap do |c|
             c.context = :module
           end

data/lib/pdk/util/changelog_generator.rb

@@ -0,0 +1,138 @@
+require 'pdk'
+
+module PDK
+  module Util
+    module ChangelogGenerator
+      # Taken from the version regex in https://forgeapi.puppet.com/schemas/module.json
+      VERSION_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?$/.freeze
+      GEM = 'github_changelog_generator'.freeze
+
+      # Raises if the github_changelog_generator is not available
+      def self.github_changelog_generator_available!
+        check_command = PDK::CLI::Exec::InteractiveCommand.new(PDK::CLI::Exec.bundle_bin, 'info', 'github_changelog_generator')
+        check_command.context = :module
+
+        result = check_command.execute!
+
+        return if result[:exit_code].zero?
+
+        raise PDK::CLI::ExitWithError, format('Unable to generate the changelog as the %{gem} gem is not included in this module\'s Gemfile', gem: GEM)
+      end
+
+      # Runs the Changelog Generator gem (in the module's context) to automatically create a CHANGLELOG.MD file
+      #
+      # @returns [String] The content of the new Changelog
+      def self.generate_changelog
+        github_changelog_generator_available!
+
+        changelog_command = PDK::CLI::Exec::InteractiveCommand.new(PDK::CLI::Exec.bundle_bin, 'exec', 'rake', 'changelog')
+        changelog_command.context = :module
+
+        result = changelog_command.execute!
+        raise PDK::CLI::ExitWithError, format('Error generating changelog: %{stdout}', stdout: result[:stdout]) unless result[:exit_code].zero?
+
+        output = changelog_content
+
+        raise PDK::CLI::ExitWithError, format('The generated changelog contains uncategorized Pull Requests. Please label them and try again. See %{changelog_file} for more details', changelog_file: changelog_file) if output.include?('UNCATEGORIZED PRS; GO LABEL THEM') # rubocop:disable Layout/LineLength
+
+        output
+      end
+
+      # Computes the next version, based on the content of a changelog
+      #
+      # @param current_version [String, Gem::Version] The current version of the module
+      # @return [String] The new version. May be the same as the current version if there are no notable changes
+      def self.compute_next_version(current_version)
+        raise PDK::CLI::ExitWithError, format('Invalid version string %{version}', version: current_version) unless VERSION_REGEX.match?(current_version)
+
+        version = Gem::Version.create(current_version).segments
+        PDK.logger.info format('Determing the target version from \'%{file}\'', file: changelog_file)
+
+        # Grab all lines that start with ## between from the latest changes
+        # For example given the changelog below
+
+        # ```
+        # # Change log
+        #
+        # All notable changes to this project will be documented in this file.
+        #
+        # ## [v4.0.0](https://github.com/puppetlabs/puppetlabs-inifile/tree/v4.
+        #
+        # [Full Changelog](https://github.com/puppetlabs/puppetlabs-inifile/com   --+
+        #                                                                           |
+        # ### Changed                                                               |
+        #                                                                           |
+        # - pdksync - FM-8499 - remove ubuntu14 support [\#363](https://github.     |  It's this piece of text we are interested in
+        #                                                                           |
+        # ### Added                                                                 |
+        #                                                                           |
+        # - FM-8402 add debian 10 support [\#352](https://github.com/puppetlabs     |
+        #                                                                           |
+        # ## [v3.1.0](https://github.com/puppetlabs/puppetlabs-inifile/tree/v3.     |
+        #                                                                         --+
+        # [Full Changelog](https://github.com/puppetlabs/puppetlabs-inifile/com
+        #
+        # ### Added
+        #
+        # - FM-8222 - Port Module inifile to Litmus [\#344](https://github.com/
+        # - \(FM-8154\) Add Windows Server 2019 support [\#340](https://github.
+        # - \(FM-8041\) Add RedHat 8 support [\#339](https://github.com/puppetl
+        # ````
+        data = ''
+        in_changelog_entry = false
+        changelog_content.each_line do |line|
+          line.strip!
+          if line.start_with?('[')
+            # We're leaving the latest changes so we can break
+            break if in_changelog_entry
+
+            in_changelog_entry = true
+          end
+          data += line if in_changelog_entry && line.start_with?('##')
+        end
+
+        # Check for meta headers in first two header line matches
+        case data
+        when /^### Changed/
+          # Major Version bump
+          version[0] += 1
+          version[1] = 0
+          version[2] = 0
+        when /^### Added/
+          # Minor Version bump
+          version[1] += 1
+          version[2] = 0
+        when /^### Fixed/
+          # Patch Version bump
+          version[2] += 1
+        end
+
+        version.join('.')
+      end
+
+      # Returns the top most version from the CHANGELOG file
+      def self.latest_version
+        latest = nil
+        changelog_content.each_line do |line|
+          line.strip!
+          if line.start_with?('## [')
+            latest = line[line.index('[') + 1..line.index(']') - 1].delete('v')
+            break # stops after the top version is extracted
+          end
+        end
+        latest
+      end
+
+      def self.changelog_file
+        # Default Changelog file is CHANGELOG.md, but also search for the .MD prefix as well.
+        @changelog_file ||= ['CHANGELOG.md', 'CHANGELOG.MD'].map { |file| PDK::Util::Filesystem.expand_path(file) }.find { |path| PDK::Util::Filesystem.file?(path) }
+      end
+
+      def self.changelog_content
+        return '' if changelog_file.nil?
+
+        PDK::Util::Filesystem.read_file(changelog_file, open_args: 'rb:utf-8')
+      end
+    end
+  end
+end