pdk 1.14.1 → 1.18.1

data/lib/pdk/util/puppet_strings.rb

@@ -92,12 +92,12 @@ module PDK
         require 'pdk/generate'
 
         generators = PDK::Generate.generators.select do |gen|
-          gen.respond_to?(:puppet_strings_type) && !gen.puppet_strings_type.nil?
+          gen.const_defined?(: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|
+        generators.map { |gen| [gen, known_objects[gen::PUPPET_STRINGS_TYPE]] }.reject do |_, obj|
           obj.nil? || obj.empty?
         end
       end
@@ -117,7 +117,7 @@ module PDK
         require 'pdk/generate'
 
         PDK::Generate.generators.find do |gen|
-          gen.respond_to?(:puppet_strings_type) && gen.puppet_strings_type == type
+          gen.const_defined?(:PUPPET_STRINGS_TYPE) && gen::PUPPET_STRINGS_TYPE == type
         end
       end
     end

data/lib/pdk/util/puppet_version.rb

@@ -52,17 +52,16 @@ module PDK
         return if options[:run] == :once && puppet_dev_fetched?
 
         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.
-          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?
 

data/lib/pdk/util/ruby_version.rb

@@ -44,7 +44,7 @@ module PDK
           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 { |ruby_dir|
             version = File.basename(ruby_dir)
             [version, version.split('.').take(2).concat(['0']).join('.')]
           }.reverse.to_h
@@ -115,9 +115,7 @@ module PDK
         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
 
@@ -128,6 +126,7 @@ module PDK
       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
@@ -142,10 +141,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 = []
@@ -167,6 +166,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

data/lib/pdk/util/template_uri.rb

@@ -7,6 +7,7 @@ module PDK
 
       PACKAGED_TEMPLATE_KEYWORD = 'pdk-default'.freeze
       DEPRECATED_TEMPLATE_URL = 'https://github.com/puppetlabs/pdk-module-template'.freeze
+      PDK_TEMPLATE_URL = 'https://github.com/puppetlabs/pdk-templates'.freeze
 
       LEGACY_PACKAGED_TEMPLATE_PATHS = {
         'windows' => 'file:///C:/Program Files/Puppet Labs/DevelopmentKit/share/cache/pdk-templates.git',
@@ -35,15 +36,14 @@ module PDK
       #
       def initialize(opts_or_uri)
         require 'addressable'
-
         # If a uri string is passed, skip the valid uri finding code.
         @uri = if opts_or_uri.is_a?(self.class)
                  opts_or_uri.uri
                elsif opts_or_uri.is_a?(String)
                  begin
                    uri, ref = opts_or_uri.split('#', 2)
-                   if self.class.packaged_template?(uri)
-                     self.class.default_template_uri(ref).uri
+                   if PDK::Util::TemplateURI.packaged_template?(uri)
+                     PDK::Util::TemplateURI.default_template_addressable_uri.tap { |default| default.fragment = ref unless ref.nil? || ref.empty? }
                    else
                      Addressable::URI.parse(opts_or_uri)
                    end
@@ -53,7 +53,7 @@ module PDK
                elsif opts_or_uri.is_a?(Addressable::URI)
                  opts_or_uri.dup
                else
-                 self.class.first_valid_uri(self.class.templates(opts_or_uri))
+                 PDK::Util::TemplateURI.first_valid_uri(PDK::Util::TemplateURI.templates(opts_or_uri))
                end
       end
 
@@ -61,28 +61,52 @@ module PDK
         @uri == other.uri
       end
 
+      def bare_uri
+        PDK::Util::TemplateURI.bare_uri(@uri)
+      end
+
       # This is the URI represented in a format suitable for writing to
       # metadata.
       #
       # @returns String
       def metadata_format
-        if self.class.packaged_template?(git_remote)
-          self.class.human_readable("pdk-default##{git_ref}")
-        else
-          self.class.human_readable(@uri.to_s)
-        end
+        @metadata_format ||= if PDK::Util::TemplateURI.packaged_template?(bare_uri)
+                               PDK::Util::TemplateURI.human_readable("pdk-default##{uri_fragment}")
+                             else
+                               PDK::Util::TemplateURI.human_readable(@uri.to_s)
+                             end
       end
       alias to_s metadata_format
       alias to_str metadata_format
 
-      # This is the url without a fragment, suitable for git clones.
-      #
+      # Returns the fragment of the URI, of the default template's ref if one does not exist
       # @returns String
-      def git_remote
-        self.class.git_remote(@uri)
+      # @api private
+      def uri_fragment
+        @uri.fragment || self.class.default_template_ref(self)
+      end
+
+      def uri_fragment=(fragment)
+        @uri.fragment = fragment
       end
 
-      def self.git_remote(uri)
+      def default?
+        bare_uri == PDK::Util::TemplateURI.bare_uri(PDK::Util::TemplateURI.default_template_addressable_uri)
+      end
+
+      def default_ref?
+        uri_fragment == self.class.default_template_ref(self)
+      end
+
+      def puppetlabs_template?
+        self.class.packaged_template?(bare_uri) || bare_uri == PDK_TEMPLATE_URL
+      end
+
+      # Class Methods
+
+      # Remove the fragment off of URI. Useful for removing the branch
+      # for Git based URIs
+      def self.bare_uri(uri)
         require 'addressable'
 
         if uri.is_a?(Addressable::URI) && uri.fragment
@@ -98,37 +122,27 @@ module PDK
         self.class.human_readable(@uri.path)
       end
 
-      # @returns String
-      def git_ref
-        @uri.fragment || self.class.default_template_ref(self)
-      end
+      # @returns PDK::Util::TemplateURI
+      def self.default_template_uri
+        require 'pdk/util'
+        require 'addressable'
 
-      def git_ref=(ref)
-        @uri.fragment = ref
+        PDK::Util::TemplateURI.new(default_template_addressable_uri)
       end
 
-      # @returns PDK::Util::TemplateURI
-      def self.default_template_uri(ref = nil)
+      # @returns Addressable::URI
+      # @api private
+      def self.default_template_addressable_uri
         require 'pdk/util'
         require 'addressable'
 
         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'), fragment: ref))
+          Addressable::URI.new(scheme: 'file', host: '', path: File.join(PDK::Util.package_cachedir, 'pdk-templates.git'))
         else
-          PDK::Util::TemplateURI.new(Addressable::URI.new(scheme: 'https', host: 'github.com', path: '/puppetlabs/pdk-templates', fragment: ref))
+          Addressable::URI.parse(PDK_TEMPLATE_URL)
         end
       end
 
-      def default?
-        git_remote == self.class.default_template_uri.git_remote
-      end
-
-      def ref_is_tag?
-        require 'pdk/util/git'
-
-        PDK::Util::Git.git('ls-remote', '--tags', '--exit-code', git_remote, git_ref)[:exit_code].zero?
-      end
-
       # `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 and so are subsequently converted to ssh:// URIs.
@@ -178,7 +192,6 @@ module PDK
       #   directory, and :allow_fallback contains a Boolean that specifies if
       #   the lookup process should proceed to the next template directory if
       #   the template file is not in this template directory.
-      #
       def self.templates(opts)
         require 'pdk/answer_file'
         require 'pdk/util'
@@ -195,7 +208,7 @@ module PDK
         else
           explicit_uri = nil
         end
-        metadata_uri = if PDK::Util.module_root && File.file?(File.join(PDK::Util.module_root, 'metadata.json'))
+        metadata_uri = if PDK::Util.module_root && PDK::Util::Filesystem.file?(File.join(PDK::Util.module_root, 'metadata.json'))
                          if PDK::Util.module_metadata['template-url']
                            new(uri_safe(PDK::Util.module_metadata['template-url'])).uri
                          else
@@ -204,10 +217,11 @@ module PDK
                        else
                          nil
                        end
-        answers_uri = if [PACKAGED_TEMPLATE_KEYWORD, DEPRECATED_TEMPLATE_URL].include?(PDK.answers['template-url'])
+        default_template_url = PDK.config.get_within_scopes('module_defaults.template-url')
+        answers_uri = if [PACKAGED_TEMPLATE_KEYWORD, DEPRECATED_TEMPLATE_URL].include?(default_template_url)
                         Addressable::URI.parse(default_template_uri)
-                      elsif PDK.answers['template-url']
-                        new(uri_safe(PDK.answers['template-url'])).uri
+                      elsif default_template_url
+                        new(uri_safe(default_template_url)).uri
                       else
                         nil
                       end
@@ -246,22 +260,20 @@ module PDK
         found_template[:uri]
       end
 
-      def self.valid_template?(template)
+      def self.valid_template?(template, context = PDK.context)
         require 'addressable'
-        require 'pdk/util/git'
-        require 'pdk/module/templatedir'
 
         return false if template.nil? || !template.is_a?(Hash)
         return false if template[:uri].nil? || !template[:uri].is_a?(Addressable::URI)
 
-        return true if PDK::Util::Git.repo?(git_remote(template[:uri]))
-
+        return true if PDK::Util::Git.repo?(bare_uri(template[:uri]))
         path = human_readable(template[:uri].path)
-        if File.directory?(path)
+        if PDK::Util::Filesystem.directory?(path)
+          # We know that it's not a git repository, but it's a valid path on disk
           begin
-            PDK::Module::TemplateDir.new(path) {}
-            return true
-          rescue ArgumentError
+            renderer = PDK::Template::Renderer.instance(path, template[:uri], context)
+            return !renderer.nil?
+          rescue StandardError
             nil
           end
         end

data/lib/pdk/util/version.rb

@@ -15,8 +15,8 @@ module PDK
       end
 
       def self.pkg_sha
-        if version_file && File.exist?(version_file)
-          ver = File.read(version_file)
+        if version_file && PDK::Util::Filesystem.exist?(version_file)
+          ver = PDK::Util::Filesystem.read_file(version_file)
           sha = ver.strip.split('.')[5] unless ver.nil?
         end
 
@@ -25,9 +25,9 @@ module PDK
 
       def self.git_ref
         require 'pdk/util/git'
-        source_git_dir = File.join(File.expand_path('../../..', File.dirname(__FILE__)), '.git')
+        source_git_dir = File.join(PDK::Util::Filesystem.expand_path('../../..', File.dirname(__FILE__)), '.git')
 
-        return unless File.directory?(source_git_dir)
+        return unless PDK::Util::Filesystem.directory?(source_git_dir)
 
         PDK::Util::Git.describe(source_git_dir)
       end

data/lib/pdk/validate.rb

@@ -2,37 +2,91 @@ require 'pdk'
 
 module PDK
   module Validate
-    # TODO: Fix validator namespacing
-    autoload :BaseValidator, 'pdk/validate/base_validator'
-    autoload :MetadataJSONLint, 'pdk/validate/metadata/metadata_json_lint'
-    autoload :MetadataSyntax, 'pdk/validate/metadata/metadata_syntax'
-    autoload :MetadataValidator, 'pdk/validate/metadata_validator'
-    autoload :PuppetEPP, 'pdk/validate/puppet/puppet_epp'
-    autoload :PuppetLint, 'pdk/validate/puppet/puppet_lint'
-    autoload :PuppetSyntax, 'pdk/validate/puppet/puppet_syntax'
-    autoload :PuppetValidator, 'pdk/validate/puppet_validator'
-    autoload :Rubocop, 'pdk/validate/ruby/rubocop'
-    autoload :RubyValidator, 'pdk/validate/ruby_validator'
-    autoload :TasksValidator, 'pdk/validate/tasks_validator'
-    autoload :YAMLValidator, 'pdk/validate/yaml_validator'
+    autoload :ExternalCommandValidator, 'pdk/validate/external_command_validator'
+    autoload :InternalRubyValidator, 'pdk/validate/internal_ruby_validator'
+    autoload :InvokableValidator, 'pdk/validate/invokable_validator'
+    autoload :Validator, 'pdk/validate/validator'
+    autoload :ValidatorGroup, 'pdk/validate/validator_group'
 
-    class Tasks
-      autoload :Name, 'pdk/validate/tasks/name'
-      autoload :MetadataLint, 'pdk/validate/tasks/metadata_lint'
+    module ControlRepo
+      autoload :ControlRepoValidatorGroup, 'pdk/validate/control_repo/control_repo_validator_group'
+      autoload :EnvironmentConfValidator, 'pdk/validate/control_repo/environment_conf_validator'
     end
 
-    class YAML
-      autoload :Syntax, 'pdk/validate/yaml/syntax'
+    module Metadata
+      autoload :MetadataJSONLintValidator, 'pdk/validate/metadata/metadata_json_lint_validator'
+      autoload :MetadataSyntaxValidator, 'pdk/validate/metadata/metadata_syntax_validator'
+      autoload :MetadataValidatorGroup, 'pdk/validate/metadata/metadata_validator_group'
+    end
+
+    module Puppet
+      autoload :PuppetEPPValidator, 'pdk/validate/puppet/puppet_epp_validator'
+      autoload :PuppetLintValidator, 'pdk/validate/puppet/puppet_lint_validator'
+      autoload :PuppetSyntaxValidator, 'pdk/validate/puppet/puppet_syntax_validator'
+      autoload :PuppetValidatorGroup, 'pdk/validate/puppet/puppet_validator_group'
+    end
+
+    module Ruby
+      autoload :RubyRubocopValidator, 'pdk/validate/ruby/ruby_rubocop_validator'
+      autoload :RubyValidatorGroup, 'pdk/validate/ruby/ruby_validator_group'
+    end
+
+    module Tasks
+      autoload :TasksMetadataLintValidator, 'pdk/validate/tasks/tasks_metadata_lint_validator'
+      autoload :TasksNameValidator, 'pdk/validate/tasks/tasks_name_validator'
+      autoload :TasksValidatorGroup, 'pdk/validate/tasks/tasks_validator_group'
+    end
+
+    module YAML
+      autoload :YAMLSyntaxValidator, 'pdk/validate/yaml/yaml_syntax_validator'
+      autoload :YAMLValidatorGroup, 'pdk/validate/yaml/yaml_validator_group'
     end
 
     def self.validators
-      @validators ||= [
-        MetadataValidator,
-        YAMLValidator,
-        PuppetValidator,
-        RubyValidator,
-        TasksValidator,
-      ].freeze
+      validator_hash.values
+    end
+
+    def self.validator_names
+      validator_hash.keys
+    end
+
+    # @api private
+    def self.validator_hash
+      # TODO: This isn't the most performant... But with only 6 items, it's fine
+      @validator_hash ||= [
+        ControlRepo::ControlRepoValidatorGroup,
+        Metadata::MetadataValidatorGroup,
+        Puppet::PuppetValidatorGroup,
+        Ruby::RubyValidatorGroup,
+        Tasks::TasksValidatorGroup,
+        YAML::YAMLValidatorGroup,
+      ].map { |klass| [klass.new.name, klass] }.to_h.freeze
+    end
+
+    def self.invoke_validators_by_name(context, names, parallel = false, options = {})
+      instances = names.select { |name| validator_names.include?(name) }
+                       .map { |name| validator_hash[name].new(context, options) }
+                       .select { |instance| instance.valid_in_context? }
+                       .each { |instance| instance.prepare_invoke! }
+      report = PDK::Report.new
+
+      # Nothing to validate then nothing to do.
+      return [0, report] if instances.empty?
+
+      require 'pdk/cli/exec_group'
+      exec_group = PDK::CLI::ExecGroup.create(
+        _('Validating module using %{num_of_threads} threads' % { num_of_threads: instances.count }),
+        { parallel: parallel },
+        options,
+      )
+
+      instances.each do |validator|
+        exec_group.register do
+          validator.invoke(report)
+        end
+      end
+
+      [exec_group.exit_code, report]
     end
 
     class ParseOutputError < StandardError; end

data/lib/pdk/validate/control_repo/control_repo_validator_group.rb

@@ -0,0 +1,23 @@
+require 'pdk'
+
+module PDK
+  module Validate
+    module ControlRepo
+      class ControlRepoValidatorGroup < ValidatorGroup
+        def name
+          'control-repo'
+        end
+
+        def valid_in_context?
+          context.is_a?(PDK::Context::ControlRepo)
+        end
+
+        def validators
+          [
+            EnvironmentConfValidator,
+          ].freeze
+        end
+      end
+    end
+  end
+end