pdk 1.4.1 → 1.5.0

data/lib/pdk/cli/validate.rb

@@ -13,6 +13,7 @@ module PDK::CLI
       'If not specified, validators are run against all applicable files in the module.',
     )
 
+    PDK::CLI.puppet_version_options(self)
     flag nil, :list, _('List all available validators.')
     flag :a, 'auto-correct', _('Automatically correct problems where possible.')
     flag nil, :parallel, _('Run validations in parallel.')
@@ -32,11 +33,15 @@ module PDK::CLI
         exit 0
       end
 
+      PDK::CLI::Util.validate_puppet_version_opts(opts)
+
       PDK::CLI::Util.ensure_in_module!(
         message:   _('Code validation can only be run from inside a valid module directory'),
         log_level: :info,
       )
 
+      PDK::CLI::Util.module_version_check
+
       if args[0]
         # This may be a single validator, a list of validators, or a target.
         if Util::OptionValidator.comma_separated_list?(args[0])
@@ -80,8 +85,10 @@ module PDK::CLI
       options = targets.empty? ? {} : { targets: targets }
       options[:auto_correct] = true if opts.key?(:'auto-correct')
 
-      # Ensure that the bundle is installed and tools are available before running any validations.
-      PDK::Util::Bundler.ensure_bundle!
+      # Ensure that the bundled gems are up to date and correct Ruby is activated before running any validations.
+      puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts)
+      PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
+      PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
 
       exit_code = 0
       if opts[:parallel]

data/lib/pdk/generate/module.rb

@@ -286,7 +286,7 @@ module PDK
         if opts[:only_ask]
           questions.reject! do |question|
             if %w[module_name forge_username].include?(question[:name])
-              metadata.data['name'] && metadata.data['name'] =~ %r{\A[a-z0-9]+-[a-z0-9]+\Z}i
+              metadata.data['name'] && metadata.data['name'] =~ %r{\A[a-z0-9]+-[a-z][a-z0-9_]*\Z}i
             else
               !opts[:only_ask].include?(question[:name])
             end

data/lib/pdk/generate/provider.rb

@@ -52,25 +52,27 @@ module PDK
         end
       end
 
-      # @return [String] the path where the new type will be written.
+      # @return [String] the path where the new provider will be written.
       def target_object_path
-        @target_object_path ||= File.join(module_dir, 'lib', 'puppet', 'type', object_name) + '.rb'
+        @target_object_path ||= File.join(module_dir, 'lib', 'puppet', 'provider', object_name, object_name) + '.rb'
       end
 
-      # @return [String] the path where the new provider will be written.
-      def target_addon_path
-        @target_addon_path ||= File.join(module_dir, 'lib', 'puppet', 'provider', object_name, object_name) + '.rb'
+      # @return [String] the path where the new type will be written.
+      def target_type_path
+        @target_type_path ||= File.join(module_dir, 'lib', 'puppet', 'type', object_name) + '.rb'
       end
 
-      # Calculates the path to the file where the tests for the new defined
-      # type will be written.
-      #
-      # @return [String] the path where the tests for the new defined type
+      # @return [String] the path where the tests for the new provider
       # will be written.
       def target_spec_path
         @target_spec_path ||= File.join(module_dir, 'spec', 'unit', 'puppet', 'provider', object_name, object_name) + '_spec.rb'
       end
 
+      # @return [String] the path where the tests for the new type will be written.
+      def target_type_spec_path
+        @target_type_spec_path ||= File.join(module_dir, 'spec', 'unit', 'puppet', 'type', object_name) + '_spec.rb'
+      end
+
       # transform a object name into a ruby class name
       def self.class_name_from_object_name(object_name)
         object_name.to_s.split('_').map(&:capitalize).join

data/lib/pdk/generate/puppet_object.rb

@@ -58,11 +58,11 @@ module PDK
         raise NotImplementedError
       end
 
-      # @abstract Subclass and implement {#target_addon_path}. Implementations
+      # @abstract Subclass and implement {#target_type_path}. Implementations
       #   of this method should return a String containing the destination path
       #   of the additional object file being generated.
       # @return [String] returns nil if there is no additional object file
-      def target_addon_path
+      def target_type_path
         nil
       end
 
@@ -73,6 +73,13 @@ module PDK
         raise NotImplementedError
       end
 
+      # @abstract Subclass and implement {#target_type_spec_path}. Implementations
+      #   of this method should return a String containing the destination path
+      #   of the tests for the object being generated.
+      def target_type_spec_path
+        nil
+      end
+
       # Retrieves the type of the object being generated, e.g. :class,
       # :defined_type, etc. This is specified in the subclass' OBJECT_TYPE
       # constant.
@@ -91,7 +98,7 @@ module PDK
       #
       # @api public
       def check_preconditions
-        [target_object_path, target_addon_path, target_spec_path].compact.each do |target_file|
+        [target_object_path, target_type_path, target_spec_path, target_type_spec_path].compact.each do |target_file|
           next unless File.exist?(target_file)
 
           raise PDK::CLI::ExitWithError, _("Unable to generate %{object_type}; '%{file}' already exists.") % {
@@ -116,8 +123,9 @@ module PDK
           data = template_data.merge(configs: config_hash)
 
           render_file(target_object_path, template_path[:object], data)
-          render_file(target_addon_path, template_path[:addon], data) if template_path[:addon]
+          render_file(target_type_path, template_path[:type], data) if template_path[:type]
           render_file(target_spec_path, template_path[:spec], data) if template_path[:spec]
+          render_file(target_type_spec_path, template_path[:type_spec], data) if template_path[:type_spec]
         end
       end
 

data/lib/pdk/module/convert.rb

@@ -66,22 +66,31 @@ module PDK
       end
 
       def stage_changes!
+        metadata_path = 'metadata.json'
+
         PDK::Module::TemplateDir.new(template_url, nil, false) do |templates|
-          new_metadata = update_metadata('metadata.json', templates.metadata)
+          new_metadata = update_metadata(metadata_path, templates.metadata)
+          templates.module_metadata = new_metadata.data unless new_metadata.nil?
 
           if options[:noop] && new_metadata.nil?
-            update_manager.add_file('metadata.json', '')
-          elsif File.file?('metadata.json')
-            update_manager.modify_file('metadata.json', new_metadata)
+            update_manager.add_file(metadata_path, '')
+          elsif File.file?(metadata_path)
+            update_manager.modify_file(metadata_path, new_metadata.to_json)
           else
-            update_manager.add_file('metadata.json', new_metadata)
+            update_manager.add_file(metadata_path, new_metadata.to_json)
           end
 
-          templates.render do |file_path, file_content|
-            if File.exist? file_path
-              update_manager.modify_file(file_path, file_content)
-            else
-              update_manager.add_file(file_path, file_content)
+          templates.render do |file_path, file_content, file_status|
+            if file_status == :unmanage
+              PDK.logger.debug(_("skipping '%{path}'") % { path: file_path })
+            elsif file_status == :delete
+              update_manager.remove_file(file_path)
+            elsif file_status == :manage
+              if File.exist? file_path
+                update_manager.modify_file(file_path, file_content)
+              else
+                update_manager.add_file(file_path, file_content)
+              end
             end
           end
         end
@@ -126,7 +135,7 @@ module PDK
         end
 
         metadata.update!(template_metadata)
-        metadata.to_json
+        metadata
       end
 
       def summary

data/lib/pdk/module/metadata.rb

@@ -87,6 +87,25 @@ module PDK
         PDK::Generate::Module.module_interview(self, only_ask: missing_fields)
       end
 
+      def validate_puppet_version_requirement!
+        msgs = {
+          no_reqs:       _('Module metadata does not contain any requirements.'),
+          no_puppet_req: _('Module metadata does not contain a "puppet" requirement.'),
+          no_puppet_ver: _('The "puppet" requirement in module metadata does not specify a "version_requirement".'),
+        }
+
+        raise ArgumentError, msgs[:no_reqs] unless @data.key?('requirements')
+        raise ArgumentError, msgs[:no_puppet_req] if puppet_requirement.nil?
+        raise ArgumentError, msgs[:no_puppet_ver] unless puppet_requirement.key?('version_requirement')
+        raise ArgumentError, msgs[:no_puppet_ver] if puppet_requirement['version_requirement'].empty?
+      end
+
+      def puppet_requirement
+        @data['requirements'].find do |r|
+          r.key?('name') && r['name'] == 'puppet'
+        end
+      end
+
       private
 
       def missing_fields

data/lib/pdk/module/templatedir.rb

@@ -8,6 +8,8 @@ require 'pdk/template_file'
 module PDK
   module Module
     class TemplateDir
+      attr_accessor :module_metadata
+
       # Initialises the TemplateDir object with the path or URL to the template
       # and the block of code to run to be run while the template is available.
       #
@@ -30,43 +32,21 @@ module PDK
       #     end
       #   end
       #
-      # @raise [PDK::CLI::FatalError] If the template is a git repository and
-      # the git binary is unavailable.
-      # @raise [PDK::CLI::FatalError] If the template is a git repository and
-      # the git clone operation fails.
+      # @raise [ArgumentError] If no block is given to this method.
+      # @raise [PDK::CLI::FatalError] (see #clone_repo)
       # @raise [ArgumentError] (see #validate_module_template!)
       #
       # @api public
       def initialize(path_or_url, module_metadata = {}, init = false)
-        if File.directory?(path_or_url)
-          @path = path_or_url
-        else
-          # If path_or_url isn't a directory on disk, we assume that it is
-          # a remote git repository.
-
-          # @todo When switching this over to using rugged, cache the cloned
-          # template repo in `%AppData%` or `$XDG_CACHE_DIR` and update before
-          # use.
-          temp_dir = PDK::Util.make_tmpdir_name('pdk-templates')
-          git_ref = (path_or_url == PDK::Util.default_template_url) ? PDK::Util.default_template_ref : 'origin/master'
-
-          clone_result = PDK::Util::Git.git('clone', path_or_url, temp_dir)
-
-          if clone_result[:exit_code].zero?
-            reset_result = PDK::Util::Git.git('-C', temp_dir, 'reset', '--hard', git_ref)
-            unless reset_result[:exit_code].zero?
-              PDK.logger.error reset_result[:stdout]
-              PDK.logger.error reset_result[:stderr]
-              raise PDK::CLI::FatalError, _("Unable to set git repository '%{repo}' to ref:'%{ref}'.") % { repo: temp_dir, ref: git_ref }
-            end
-          else
-            PDK.logger.error clone_result[:stdout]
-            PDK.logger.error clone_result[:stderr]
-            raise PDK::CLI::FatalError, _("Unable to clone git repository '%{repo}' to '%{dest}'.") % { repo: path_or_url, dest: temp_dir }
-          end
+        unless block_given?
+          raise ArgumentError, _('%{class_name} must be initialized with a block.') % { class_name: self.class.name }
+        end
 
-          @path = PDK::Util.canonical_path(temp_dir)
+        if PDK::Util::Git.repo?(path_or_url)
+          @path = self.class.clone_template_repo(path_or_url)
           @repo = path_or_url
+        else
+          @path = path_or_url
         end
 
         @init = init
@@ -75,6 +55,7 @@ module PDK
         @dirs = [@moduleroot_dir]
         @dirs << @moduleroot_init if @init
         @object_dir = File.join(@path, 'object_templates')
+
         validate_module_template!
 
         @module_metadata = module_metadata
@@ -127,16 +108,26 @@ module PDK
           template_file = template_file.to_s
           PDK.logger.debug(_("Rendering '%{template}'...") % { template: template_file })
           dest_path = template_file.sub(%r{\.erb\Z}, '')
-          begin
-            dest_content = PDK::TemplateFile.new(File.join(template_loc, template_file), configs: config_for(dest_path)).render
-          rescue => e
-            error_msg = _(
-              "Failed to render template '%{template}'\n" \
-              '%{exception}: %{message}',
-            ) % { template: template_file, exception: e.class, message: e.message }
-            raise PDK::CLI::FatalError, error_msg
+          config = config_for(dest_path)
+          dest_status = :manage
+
+          if config['unmanaged']
+            dest_status = :unmanage
+          elsif config['delete']
+            dest_status = :delete
+          else
+            begin
+              dest_content = PDK::TemplateFile.new(File.join(template_loc, template_file), configs: config).render
+            rescue => e
+              error_msg = _(
+                "Failed to render template '%{template}'\n" \
+                '%{exception}: %{message}',
+              ) % { template: template_file, exception: e.class, message: e.message }
+              raise PDK::CLI::FatalError, error_msg
+            end
           end
-          yield dest_path, dest_content
+
+          yield dest_path, dest_content, dest_status
         end
       end
 
@@ -155,13 +146,15 @@ module PDK
       # @api public
       def object_template_for(object_type)
         object_path = File.join(@object_dir, "#{object_type}.erb")
-        addon_path = File.join(@object_dir, "#{object_type}_addon.erb")
+        type_path = File.join(@object_dir, "#{object_type}_type.erb")
         spec_path = File.join(@object_dir, "#{object_type}_spec.erb")
+        type_spec_path = File.join(@object_dir, "#{object_type}_type_spec.erb")
 
         if File.file?(object_path) && File.readable?(object_path)
           result = { object: object_path }
-          result[:addon] = addon_path if File.file?(addon_path) && File.readable?(addon_path)
+          result[:type] = type_path if File.file?(type_path) && File.readable?(type_path)
           result[:spec] = spec_path if File.file?(spec_path) && File.readable?(spec_path)
+          result[:type_spec] = type_spec_path if File.file?(type_spec_path) && File.readable?(type_spec_path)
           result
         else
           nil
@@ -282,6 +275,37 @@ module PDK
           {}
         end
       end
+
+      # @return [String] Path to working directory into which template repo has been cloned and reset
+      #
+      # @raise [PDK::CLI::FatalError] If unable to clone the given origin_repo into a tempdir.
+      # @raise [PDK::CLI::FatalError] If reset HEAD of the cloned repo to desired ref.
+      #
+      # @api private
+      def self.clone_template_repo(origin_repo)
+        # @todo When switching this over to using rugged, cache the cloned
+        # template repo in `%AppData%` or `$XDG_CACHE_DIR` and update before
+        # use.
+        temp_dir = PDK::Util.make_tmpdir_name('pdk-templates')
+        git_ref = (origin_repo == PDK::Util.default_template_url) ? PDK::Util.default_template_ref : 'origin/master'
+
+        clone_result = PDK::Util::Git.git('clone', origin_repo, temp_dir)
+
+        if clone_result[:exit_code].zero?
+          reset_result = PDK::Util::Git.git('-C', temp_dir, 'reset', '--hard', git_ref)
+          unless reset_result[:exit_code].zero?
+            PDK.logger.error reset_result[:stdout]
+            PDK.logger.error reset_result[:stderr]
+            raise PDK::CLI::FatalError, _("Unable to set HEAD of git repository at '%{repo}' to ref:'%{ref}'.") % { repo: temp_dir, ref: git_ref }
+          end
+        else
+          PDK.logger.error clone_result[:stdout]
+          PDK.logger.error clone_result[:stderr]
+          raise PDK::CLI::FatalError, _("Unable to clone git repository at '%{repo}' into '%{dest}'.") % { repo: origin_repo, dest: temp_dir }
+        end
+
+        PDK::Util.canonical_path(temp_dir)
+      end
     end
   end
 end

data/lib/pdk/module/update.rb

@@ -8,14 +8,14 @@ module PDK
       def run
         stage_changes!
 
+        if current_version == new_version
+          PDK.logger.debug _('This module is already up to date with version %{version} of the template.') % {
+            version: new_version,
+          }
+        end
+
         unless update_manager.changes?
-          if current_version == new_version
-            PDK.logger.info _('This module is already up to date with version %{version} of the template.') % {
-              version: new_version,
-            }
-          else
-            PDK::Report.default_target.puts(_('No changes required.'))
-          end
+          PDK::Report.default_target.puts(_('No changes required.'))
           return
         end
 

data/lib/pdk/tests/unit.rb

@@ -18,7 +18,7 @@ module PDK
 
       def self.rake(task, spinner_text, environment = {})
         argv = [rake_bin, task]
-        argv.unshift('ruby') if Gem.win_platform?
+        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
@@ -62,7 +62,6 @@ module PDK
       end
 
       def self.invoke(report, options = {})
-        PDK::Util::Bundler.ensure_bundle!
         PDK::Util::Bundler.ensure_binstubs!('rake')
 
         setup
@@ -181,11 +180,11 @@ module PDK
 
       # @return array of { :id, :full_description }
       def self.list
-        PDK::Util::Bundler.ensure_bundle!
         PDK::Util::Bundler.ensure_binstubs!('rake')
 
         command_argv = [File.join(PDK::Util.module_root, 'bin', 'rake'), 'spec_list_json']
-        command_argv.unshift('ruby') if Gem.win_platform?
+        command_argv.unshift(File.join(PDK::Util::RubyVersion.bin_path, 'ruby.exe')) if Gem.win_platform?
+
         list_command = PDK::CLI::Exec::Command.new(*command_argv)
         list_command.context = :module
         output = list_command.execute!

data/lib/pdk/util.rb

@@ -3,9 +3,19 @@ require 'tempfile'
 
 require 'pdk/util/version'
 require 'pdk/util/windows'
+require 'pdk/util/vendored_file'
 
 module PDK
   module Util
+    MODULE_FOLDERS = %w[
+      manifests
+      lib
+      tasks
+      facts.d
+      functions
+      types
+    ].freeze
+
     # Searches upwards from current working directory for the given target file.
     #
     # @param target [String] Name of file to search for.
@@ -32,7 +42,9 @@ module PDK
     #
     # @return [String] The temporary directory path.
     def make_tmpdir_name(base)
-      Dir::Tmpname.make_tmpname(File.join(Dir.tmpdir, base), nil)
+      t = Time.now.strftime('%Y%m%d')
+      name = "#{base}#{t}-#{Process.pid}-#{rand(0x100000000).to_s(36)}"
+      File.join(Dir.tmpdir, name)
     end
     module_function :make_tmpdir_name
 
@@ -100,12 +112,24 @@ module PDK
       metadata_path = find_upwards('metadata.json')
       if metadata_path
         File.dirname(metadata_path)
+      elsif in_module_root?
+        Dir.pwd
       else
         nil
       end
     end
     module_function :module_root
 
+    # Returns true or false depending on if any of the common directories in a module
+    # are found in the current directory
+    #
+    # @return [boolean] True if any folders from MODULE_FOLDERS are found in the current dir,
+    #   false otherwise.
+    def in_module_root?
+      PDK::Util::MODULE_FOLDERS.any? { |dir| File.directory?(dir) }
+    end
+    module_function :in_module_root?
+
     # Iterate through possible JSON documents until we find one that is valid.
     #
     # @param [String] text the text in which to find a JSON document
@@ -181,7 +205,7 @@ module PDK
       return puppetlabs_template_url if answer_file_url == 'https://github.com/puppetlabs/pdk-module-template'
       return puppetlabs_template_url if answer_file_url == puppetlabs_template_url
 
-      unless PDK::Util::Git.repo_exists?(answer_file_url)
+      unless PDK::Util::Git.repo?(answer_file_url)
         PDK.logger.warn(_("Unable to access the previously used template '%{template}', using the default template instead.") % { template: answer_file_url })
         PDK.answers.update!('template-url' => nil)
         return puppetlabs_template_url
@@ -228,5 +252,16 @@ module PDK
       ['pdk-version', 'template-url'].any? { |key| module_metadata.key?(key) }
     end
     module_function :module_pdk_compatible?
+
+    def module_pdk_version
+      metadata = module_metadata
+
+      if !metadata.nil? && metadata.include?('pdk-version')
+        metadata['pdk-version'].split.first
+      else
+        nil
+      end
+    end
+    module_function :module_pdk_version
   end
 end