pdk-akerl 1.9.1.1 → 1.14.0.1

data/lib/pdk/util/bundler.rb

@@ -1,15 +1,11 @@
-require 'bundler'
-require 'digest'
-require 'fileutils'
-require 'pdk/util'
-require 'pdk/cli/exec'
-
 module PDK
   module Util
     module Bundler
       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
@@ -70,6 +66,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 +75,12 @@ 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
 
@@ -104,14 +103,14 @@ 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 'fileutils'
+          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.
@@ -140,7 +139,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 +180,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
 
@@ -189,6 +188,8 @@ module PDK
         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')
 
@@ -200,7 +201,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 +216,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
 
@@ -243,6 +244,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/filesystem.rb

@@ -4,9 +4,72 @@ module PDK
       def write_file(path, content)
         raise ArgumentError unless path.is_a?(String) || path.respond_to?(:to_path)
 
-        File.open(path, 'wb') { |f| f.write(content.encode(universal_newline: true)) }
+        # Harmonize newlines across platforms.
+        content = content.encode(universal_newline: true)
+
+        # Make sure all written files have a trailing newline.
+        content += "\n" unless content[-1] == "\n"
+
+        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 mkdir_p(*args)
+        FileUtils.mkdir_p(*args)
+      end
+      module_function :mkdir_p
+
+      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
+
+      def readable?(*args)
+        File.readable?(*args)
+      end
+      module_function :readable?
+
+      def exist?(*args)
+        File.exist?(*args)
+      end
+      module_function :exist?
+
+      def rm(*args)
+        FileUtils.rm(*args)
+      end
+      module_function :rm
+      #:nocov:
     end
   end
 end

data/lib/pdk/util/git.rb

@@ -1,5 +1,21 @@
 module PDK
   module Util
+    class GitError < StandardError
+      attr_reader :stdout
+      attr_reader :stderr
+      attr_reader :exit_code
+      attr_reader :args
+
+      def initialze(args, result)
+        @args = args
+        @stdout = result[:stdout]
+        @stderr = result[:stderr]
+        @exit_code = result[:exit_code]
+
+        super(_('Git command failed: git %{args}' % { args: args.join(' ') }))
+      end
+    end
+
     module Git
       def self.git_bindir
         @git_dir ||= File.join('private', 'git', Gem.win_platform? ? 'cmd' : 'bin')
@@ -20,6 +36,8 @@ module PDK
       end
 
       def self.git_bin
+        require 'pdk/cli/exec'
+
         git_bin = Gem.win_platform? ? 'git.exe' : 'git'
         vendored_bin_path = File.join(git_bindir, git_bin)
 
@@ -27,12 +45,16 @@ module PDK
       end
 
       def self.git(*args)
+        require 'pdk/cli/exec'
+
         PDK::CLI::Exec.ensure_bin_present!(git_bin, 'git')
 
         PDK::CLI::Exec.execute(git_bin, *args)
       end
 
       def self.git_with_env(env, *args)
+        require 'pdk/cli/exec'
+
         PDK::CLI::Exec.ensure_bin_present!(git_bin, 'git')
 
         PDK::CLI::Exec.execute_with_env(env, git_bin, *args)
@@ -55,7 +77,27 @@ module PDK
         git('ls-remote', '--exit-code', maybe_repo)[:exit_code].zero?
       end
 
+      def self.work_tree?(path)
+        return false unless File.directory?(path)
+
+        Dir.chdir(path) do
+          rev_parse = git('rev-parse', '--is-inside-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'))
+
+        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)
+          repo = 'file://' + repo
+        end
+
         output = git('ls-remote', '--refs', repo, ref)
 
         unless output[:exit_code].zero?
@@ -67,7 +109,16 @@ module PDK
         end
 
         matching_refs = output[:stdout].split("\n").map { |r| r.split("\t") }
-        matching_refs.find { |_sha, remote_ref| remote_ref == ref }.first
+        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_ref.first
+      end
+
+      def self.describe(path, ref = nil)
+        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
     end
   end

data/lib/pdk/util/puppet_strings.rb

@@ -0,0 +1,123 @@
+module PDK
+  module Util
+    module PuppetStrings
+      class NoObjectError < StandardError; end
+      class RunError < StandardError; end
+      class NoGeneratorError < StandardError; end
+
+      # Runs Puppet for the purposes of generating puppet-strings output.
+      #
+      # @param *args [String] additional parameters to pass to puppet.
+      #
+      # @return [Hash{Symbol=>Object}] the result of the command execution.
+      def self.puppet(*args)
+        require 'pdk/cli/exec/command'
+
+        PDK::Util::Bundler.ensure_binstubs!('puppet')
+
+        argv = [File.join(PDK::Util.module_root, 'bin', 'puppet')] + args
+        argv.unshift(File.join(PDK::Util::RubyVersion.bin_path, 'ruby.exe')) if Gem.win_platform?
+
+        command = PDK::CLI::Exec::Command.new(*argv).tap do |c|
+          c.context = :module
+          c.add_spinner(_('Examining module contents'))
+        end
+
+        command.execute!
+      end
+
+      # Generates and parses the JSON output from puppet-strings.
+      #
+      # @returns [Hash{String=>Object}] the parsed puppet-strings output.
+      #
+      # @raises [PDK::Util::PuppetStrings::RunError] if the puppet-strings
+      #   command exits non-zero.
+      # @raises [PDK::Util::PuppetStrings::RunError] if the puppet-strings
+      #   command outputs invalid JSON.
+      def self.generate_hash
+        result = puppet('strings', 'generate', '--format', 'json')
+
+        raise RunError, result[:stderr] unless result[:exit_code].zero?
+
+        JSON.parse(result[:stdout])
+      rescue JSON::ParserError => e
+        PDK.logger.debug(e)
+        raise RunError, _('Unable to parse puppet-strings output')
+      end
+
+      # Searches the puppet-strings result to find the definition of the named
+      # object.
+      #
+      # @param name [String] the name of the object definition to search for.
+      #   If the object name is not prepended with the module name,
+      #   "#{module_name}::#{object_name}" will also be search for.
+      #
+      # @returns [Array[PDK::Generate::PuppetObject, Hash{String=>Object}]] the
+      #   appropriate generator class for the object as the first element and
+      #   the puppet-strings description hash for the definition.
+      #
+      # @raises [PDK::Util::PuppetStrings::NoObjectError] if the named object
+      #   can not be found in the puppet-strings output.
+      # @raises [PDK::Util::PuppetStrings::NoGeneratorError] if the named
+      #   object does not have a corresponding PDK generator class.
+      def self.find_object(name)
+        module_name = PDK::Util.module_metadata['name'].rpartition('-').last
+
+        object_names = [name]
+        object_names << "#{module_name}::#{name}" unless name.start_with?("#{module_name}::")
+
+        known_objects = generate_hash
+        object_type = known_objects.keys.find do |obj_type|
+          known_objects[obj_type].any? { |obj| object_names.include?(obj['name']) }
+        end
+
+        raise NoObjectError if object_type.nil?
+
+        generator = find_generator(object_type)
+
+        raise NoGeneratorError, object_type if generator.nil?
+
+        [generator, known_objects[object_type].find { |obj| object_names.include?(obj['name']) }]
+      end
+
+      # Generate a list of all objects that PDK has a generator for.
+      #
+      # @returns [Array[Array[PDK::Generate::PuppetObject,
+      #   Array[Hash{String=>Object}]]]] an associative array where the first
+      #   element of each pair is the generator class and the second element of
+      #   each pair is an array of description hashes from puppet-strings.
+      def self.all_objects
+        require 'pdk/generate'
+
+        generators = PDK::Generate::GENERATORS.select do |gen|
+          gen.respond_to?(:puppet_strings_type) && !gen.puppet_strings_type.nil?
+        end
+
+        known_objects = generate_hash
+
+        generators.map { |gen| [gen, known_objects[gen.puppet_strings_type]] }.reject do |_, obj|
+          obj.nil? || obj.empty?
+        end
+      end
+
+      # Evaluates the mapping of puppet-strings object type to PDK generator
+      # class.
+      #
+      # @param type [String] the object type as returned from puppet-strings.
+      #
+      # @returns [PDK:Generate::PuppetObject,nil] a child of
+      #   PDK::Generate::PuppetObject or nil a suitable generator is not found.
+      #
+      # @example
+      #   PDK::Util::PuppetStrings.find_generator('puppet_classes')
+      #   => PDK::Generate::PuppetClass
+      def self.find_generator(type)
+        require 'pdk/generate'
+
+        PDK::Generate::GENERATORS.find do |gen|
+          gen.respond_to?(:puppet_strings_type) && gen.puppet_strings_type == type
+        end
+      end
+    end
+  end
+end

data/lib/pdk/util/puppet_version.rb

@@ -1,6 +1,3 @@
-require 'pdk/util'
-require 'pdk/util/git'
-
 module PDK
   module Util
     class PuppetVersion
@@ -21,6 +18,8 @@ module PDK
       DEFAULT_PUPPET_DEV_BRANCH = 'master'.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,
@@ -28,6 +27,8 @@ module PDK
       end
 
       def puppet_dev_path
+        require 'pdk/util'
+
         File.join(PDK::Util.cachedir, 'src', 'puppet')
       end
 
@@ -42,6 +43,9 @@ module PDK
       end
 
       def fetch_puppet_dev
+        require 'pdk/util/git'
+        require 'fileutils'
+
         # 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.
@@ -56,7 +60,7 @@ module PDK
 
           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, _("Unable to clone git repository from '%{repo}'.") % { repo: DEFAULT_PUPPET_DEV_URL }
         end
 
         # Fetch Updates from remote repository
@@ -133,12 +137,15 @@ module PDK
       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
+            return
           end
 
           metadata = PDK::Module::Metadata.from_file(metadata_file)
@@ -191,6 +198,8 @@ module PDK
       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)
@@ -205,17 +214,19 @@ module PDK
       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 { |a, b| b <=> a }
         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,11 +235,15 @@ 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
 
       def find_in_package_cache(requirement)
+        require 'pdk/util/ruby_version'
+
         PDK::Util::RubyVersion.versions.each do |ruby_version, _|
           PDK::Util::RubyVersion.use(ruby_version)
           version = PDK::Util::RubyVersion.available_puppet_versions.find { |r| requirement.satisfied_by?(r) }