pdk 1.14.1 → 1.18.1

data/lib/pdk/util/bundler.rb

@@ -6,8 +6,6 @@ module PDK
       class BundleHelper; end
 
       def self.ensure_bundle!(gem_overrides = nil)
-        require 'fileutils'
-
         bundle = BundleHelper.new
 
         # This will default ensure_bundle! to re-resolving everything to latest
@@ -34,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)
@@ -91,7 +89,7 @@ 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 = {})
@@ -110,7 +108,6 @@ module PDK
 
         def lock!
           require 'pdk/util'
-          require 'fileutils'
           require 'pdk/util/ruby_version'
 
           if PDK::Util.package_install?
@@ -121,7 +118,9 @@ module PDK
               File.join(PDK::Util.package_cachedir, 'Gemfile.lock'),
             ]
 
-            vendored_gemfile_lock = vendored_lockfiles.find { |lockfile| File.exist?(lockfile) }
+            vendored_gemfile_lock = vendored_lockfiles.find do |lockfile|
+              PDK::Util::Filesystem.exist?(lockfile)
+            end
 
             unless vendored_gemfile_lock
               raise PDK::CLI::FatalError, _('Vendored Gemfile.lock (%{source}) not found.') % {
@@ -130,7 +129,7 @@ module PDK
             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'))
+            PDK::Util::Filesystem.cp(vendored_gemfile_lock, File.join(PDK::Util.module_root, 'Gemfile.lock'))
           else
             argv = ['lock']
 
@@ -211,8 +210,9 @@ module PDK
         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!

data/lib/pdk/util/changelog_generator.rb

@@ -0,0 +1,120 @@
+require 'pdk'
+
+module PDK
+  module Util
+    module ChangelogGenerator
+      # Taken from the version regex in https://forgeapi.puppet.com/schemas/module.json
+      VERSION_REGEX = %r{^(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-]+)*)?$}
+      GEM = 'github_changelog_generator'.freeze
+
+      # Raises if the github_changelog_generator is not available
+      def self.github_changelog_generator_available!
+        require 'bundler'
+        return if ::Bundler.rubygems.find_name(GEM).any?
+
+        raise PDK::CLI::ExitWithError, _(
+          'Unable to generate the changelog as the %{gem} gem is not installed',
+        ) % { 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, _('Error generating changelog: %{stdout}' % { stdout: result[:stdout] }) unless result[:exit_code].zero?
+
+        output = changelog_content
+
+        raise PDK::CLI::ExitWithError, _('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 =~ %r{UNCATEGORIZED PRS; GO LABEL THEM} # rubocop:disable Metrics/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, _('Invalid version string %{version}' % { version: current_version }) unless current_version =~ VERSION_REGEX
+        version = Gem::Version.create(current_version).segments
+        PDK.logger.info _('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
+          if in_changelog_entry && line.start_with?('##')
+            data += line
+          end
+        end
+
+        # Check for meta headers in first two header line matches
+        if data =~ %r{^### Changed}
+          # Major Version bump
+          version[0] += 1
+          version[1] = 0
+          version[2] = 0
+        elsif data =~ %r{^### Added}
+          # Minor Version bump
+          version[1] += 1
+          version[2] = 0
+        elsif data =~ %r{^### Fixed}
+          # Patch Version bump
+          version[2] += 1
+        end
+
+        version.join('.')
+      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

data/lib/pdk/util/env.rb

@@ -4,25 +4,42 @@ require 'forwardable'
 module PDK
   module Util
     class Env
-      class << self
+      class WindowsEnv
         extend Forwardable
 
-        def_delegators :env_hash, :[], :key?, :fetch, :select, :reject
+        # Note, these delegators may not have case insensitive keys
+        def_delegators :env_hash, :fetch, :select, :reject
 
         def []=(key, value)
-          if Gem.win_platform?
-            PDK::Util::Windows::Process.set_environment_variable(key, value)
-          else
-            ENV[key] = value
+          PDK::Util::Windows::Process.set_environment_variable(key, value)
+        end
+
+        def key?(key)
+          !env_hash.keys.find { |item| key.casecmp(item).zero? }.nil?
+        end
+
+        def [](key)
+          env_hash.each do |item, value|
+            next unless key.casecmp(item).zero?
+            return value
           end
+          nil
         end
 
+        private
+
         def env_hash
-          if Gem.win_platform?
-            PDK::Util::Windows::Process.environment_hash
-          else
-            ENV
-          end
+          PDK::Util::Windows::Process.environment_hash
+        end
+      end
+
+      class << self
+        extend Forwardable
+
+        def_delegators :implementation, :key?, :[], :[]=, :fetch, :select, :reject
+
+        def implementation
+          @implementation ||= Gem.win_platform? ? WindowsEnv.new : ENV
         end
       end
     end

data/lib/pdk/util/filesystem.rb

@@ -1,4 +1,5 @@
 require 'pdk'
+autoload :FileUtils, 'fileutils'
 
 module PDK
   module Util
@@ -17,8 +18,8 @@ module PDK
       end
       module_function :write_file
 
-      def read_file(file, nil_on_error: false)
-        File.read(file)
+      def read_file(file, nil_on_error: false, open_args: 'r')
+        File.read(file, open_args: Array(open_args))
       rescue => e
         raise e unless nil_on_error
         nil
@@ -58,6 +59,11 @@ module PDK
       end
       module_function :fnmatch
 
+      def fnmatch?(*args)
+        File.fnmatch?(*args)
+      end
+      module_function :fnmatch?
+
       def readable?(*args)
         File.readable?(*args)
       end
@@ -72,6 +78,60 @@ module PDK
         FileUtils.rm(*args)
       end
       module_function :rm
+
+      def rm_f(*args)
+        FileUtils.rm_f(*args)
+      end
+      module_function :rm_f
+
+      def rm_rf(*args)
+        FileUtils.rm_rf(*args)
+      end
+      module_function :rm_rf
+
+      def remove_entry_secure(*args)
+        FileUtils.remove_entry_secure(*args)
+      end
+      module_function :remove_entry_secure
+
+      def zero?(*args)
+        File.zero?(*args)
+      end
+      module_function :zero?
+
+      def stat(*args)
+        File.stat(*args)
+      end
+      module_function :stat
+
+      def symlink?(*args)
+        File.symlink?(*args)
+      end
+      module_function :symlink?
+
+      def cp(*args)
+        FileUtils.cp(*args)
+      end
+      module_function :cp
+
+      def mv(*args)
+        FileUtils.mv(*args)
+      rescue Errno::ENOENT
+        # PDK-1169 - FileUtils.mv raises Errno::ENOENT when moving files inside
+        #            VMWare shared folders on Windows. So we need to catch this
+        #            case, check if the file exists to see if the exception is
+        #            legit and "move" the file with cp & rm.
+        src, dest, opts = args
+        raise unless File.exist?(src)
+
+        FileUtils.cp(src, dest, preserve: true)
+        if (opts ||= {})[:secure]
+          FileUtils.remove_entry_secure(src, opts[:force])
+        else
+          FileUtils.remove_entry(src, opts[:force])
+        end
+      end
+      module_function :mv
       #:nocov:
     end
   end

data/lib/pdk/util/git.rb

@@ -19,6 +19,8 @@ module PDK
     end
 
     module Git
+      GIT_QUERY_CACHE_TTL ||= 10
+
       def self.git_bindir
         @git_dir ||= File.join('private', 'git', Gem.win_platform? ? 'cmd' : 'bin')
       end
@@ -63,9 +65,16 @@ module PDK
       end
 
       def self.repo?(maybe_repo)
-        return bare_repo?(maybe_repo) if File.directory?(maybe_repo)
-
-        remote_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
+                   work_tree?(maybe_repo) || bare_repo?(maybe_repo)
+                 else
+                   remote_repo?(maybe_repo)
+                 end
+        cache_query_result(maybe_repo, :repo?, result)
       end
 
       def self.bare_repo?(maybe_repo)
@@ -80,23 +89,25 @@ module PDK
       end
 
       def self.work_tree?(path)
-        return false unless File.directory?(path)
+        return false unless PDK::Util::Filesystem.directory?(path)
+        result = cached_git_query(path, :work_tree?)
+        return result unless result.nil?
 
         Dir.chdir(path) do
           rev_parse = git('rev-parse', '--is-inside-work-tree')
-          rev_parse[:exit_code].zero? && rev_parse[:stdout].strip == 'true'
+          cache_query_result(path, :work_tree?, rev_parse[:exit_code].zero? && rev_parse[:stdout].strip == 'true')
         end
       end
 
       def self.work_dir_clean?(repo)
-        raise PDK::CLI::ExitWithError, _('Unable to locate git work dir "%{workdir}"') % { workdir: repo } unless File.directory?(repo)
-        raise PDK::CLI::ExitWithError, _('Unable to locate git dir "%{gitdir}"') % { gitdir: repo } unless File.directory?(File.join(repo, '.git'))
+        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'))
 
         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 File.directory?(repo)
+        if PDK::Util::Filesystem.directory?(repo)
           repo = 'file://' + repo
         end
 
@@ -122,6 +133,47 @@ module PDK
         raise PDK::Util::GitError, args, result unless result[:exit_code].zero?
         result[:stdout].strip
       end
+
+      def self.tag?(git_remote, tag_name)
+        git('ls-remote', '--tags', '--exit-code', git_remote, tag_name)[:exit_code].zero?
+      end
+
+      # Clears any cached information for git queries
+      # Should only be used during testing
+      # @api private
+      def self.clear_cached_information
+        @git_repo_expire_cache = nil
+        @git_repo_cache = nil
+      end
+
+      def self.cached_git_query(repo, query)
+        # TODO: Not thread safe
+        if @git_repo_expire_cache.nil?
+          @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
+
+      def self.cache_query_result(repo, query, result)
+        # TODO: Not thread safe?
+        if @git_repo_expire_cache.nil?
+          @git_repo_expire_cache = Time.now + GIT_QUERY_CACHE_TTL
+          @git_repo_cache = {}
+        end
+        if @git_repo_cache[repo].nil?
+          @git_repo_cache[repo] = { query => result }
+        else
+          @git_repo_cache[repo][query] = result
+        end
+        result
+      end
+      private_class_method :cache_query_result
     end
   end
 end

data/lib/pdk/util/json_finder.rb

@@ -0,0 +1,84 @@
+module PDK
+  module Util
+    # Processes a given string, looking for JSON objects and parsing them.
+    #
+    # @example A string with a JSON object and some junk characters
+    #   PDK::Util::JSONFinder.new('foo{"bar":1}').objects
+    #   => [{ 'bar' => 1 }]
+    #
+    # @example A string with mulitple JSON objects
+    #   PDK::Util::JSONFinder.new('foo{"bar":1}baz{"gronk":2}').objects
+    #   => [{ 'bar' => 1 }, { 'gronk' => 2 }]
+    class JSONFinder
+      # Creates a new instance of PDK::Util::JSONFinder.
+      #
+      # @param string [String] the string to find JSON objects inside of.
+      #
+      # @return [PDK::Util::JSONFinder] a new PDK::Util::JSONFinder object.
+      def initialize(string)
+        require 'strscan'
+
+        @scanner = StringScanner.new(string)
+      end
+
+      # Returns the parsed JSON objects from the string.
+      #
+      # @return [Array[Hash]] the parsed JSON objects present in the string.
+      def objects
+        return @objects unless @objects.nil?
+
+        require 'json'
+
+        until @scanner.eos?
+          @scanner.getch until @scanner.peek(1) == '{' || @scanner.eos?
+
+          (@objects ||= []) << begin
+                                 JSON.parse(read_object(true) || '')
+                               rescue JSON::ParserError
+                                 nil
+                               end
+        end
+
+        @objects = @objects.compact
+      end
+
+      private
+
+      # Recursively process the string to extract a complete JSON object.
+      #
+      # @param new_object [Boolean] Set to true if processing a new object to
+      #   capture the opening brace. Set to false if being called recursively
+      #   where the opening brace has already been captured.
+      #
+      # @return [String] The matched substring containing a JSON object.
+      def read_object(new_object = false)
+        matched_text = new_object ? @scanner.getch : ''
+
+        until @scanner.eos?
+          text = @scanner.scan_until(%r{(?:(?<!\\)"|\{|\})})
+          unless text
+            @scanner.terminate
+            return nil
+          end
+          matched_text += text
+
+          case @scanner.matched
+          when '}'
+            break
+          when '"'
+            text = @scanner.scan_until(%r{(?<!\\)"})
+            unless text
+              @scanner.terminate
+              return nil
+            end
+            matched_text += text
+          else
+            matched_text += read_object
+          end
+        end
+
+        matched_text
+      end
+    end
+  end
+end