pdk 1.17.0 → 1.18.0

data/lib/pdk/generate/task.rb

@@ -3,44 +3,21 @@ require 'pdk'
 module PDK
   module Generate
     class Task < PuppetObject
-      OBJECT_TYPE = :task
+      def friendly_name
+        'Task'
+      end
 
-      # Prepares the data needed to render the new task template.
-      #
-      # @return [Hash{Symbol => Object}] a hash of information that will be
-      # provided to the task template during rendering. Additionally, this hash
-      # (with the :name key removed) makes up the task metadata.
-      def template_data
+      def template_files
+        return {} if spec_only?
         {
-          name:                object_name,
-          puppet_task_version: 1,
-          supports_noop:       false,
-          description:         options.fetch(:description, 'A short description of this task'),
-          parameters:          {},
+          'task.erb' => File.join('tasks', task_name + '.sh'),
         }
       end
 
-      # Calculates the path to the file where the new task will be written.
-      #
-      # @return [String] the path to the task file.
-      def target_object_path
-        @target_object_path ||= File.join(module_dir, 'tasks', "#{task_name}.sh")
-      end
-
-      # Calculates the path to the file where the tests for the new task will
-      # be written.
-      #
-      # @return [nil] as there is currently no test framework for Tasks.
-      def target_spec_path
-        nil
-      end
-
-      def run
-        check_if_task_already_exists
-
-        super
-
-        write_task_metadata
+      def template_data
+        {
+          name: object_name,
+        }
       end
 
       # Checks that the task has not already been defined with a different
@@ -48,30 +25,26 @@ module PDK
       #
       # @raise [PDK::CLI::ExitWithError] if files with the same name as the
       # task exist in the <module>/tasks/ directory
-      #
-      # @api private
-      def check_if_task_already_exists
+      def check_preconditions
+        super
+
         error = _("A task named '%{name}' already exists in this module; defined in %{file}")
         allowed_extensions = %w[.md .conf]
 
-        PDK::Util::Filesystem.glob(File.join(module_dir, 'tasks', "#{task_name}.*")).each do |file|
+        PDK::Util::Filesystem.glob(File.join(context.root_path, 'tasks', task_name + '.*')).each do |file|
           next if allowed_extensions.include?(File.extname(file))
 
           raise PDK::CLI::ExitWithError, error % { name: task_name, file: file }
         end
       end
 
-      # Writes the <module>/tasks/<task_name>.json metadata file for the task.
-      #
-      # @api private
-      def write_task_metadata
-        write_file(File.join(module_dir, 'tasks', "#{task_name}.json")) do
-          task_metadata = template_data.dup
-          task_metadata.delete(:name)
-          JSON.pretty_generate(task_metadata)
-        end
+      def non_template_files
+        task_metadata_file = File.join('tasks', task_name + '.json')
+        { task_metadata_file => JSON.pretty_generate(task_metadata) }
       end
 
+      private
+
       # Calculates the file name of the task files ('init' if the task has the
       # same name as the module, otherwise use the specified task name).
       #
@@ -81,6 +54,15 @@ module PDK
       def task_name
         (object_name == module_name) ? 'init' : object_name
       end
+
+      def task_metadata
+        {
+          puppet_task_version: 1,
+          supports_noop:       false,
+          description:         options.fetch(:description, 'A short description of this task'),
+          parameters:          {},
+        }
+      end
     end
   end
 end

data/lib/pdk/generate/transport.rb

@@ -2,85 +2,31 @@ require 'pdk'
 
 module PDK
   module Generate
-    class Transport < PuppetObject
-      OBJECT_TYPE = :transport
-
-      # Prepares the data needed to render the new defined type template.
-      #
-      # @return [Hash{Symbol => Object}] a hash of information that will be
-      # provided to the defined type and defined type spec templates during
-      # rendering.
-      def template_data
-        data = {
-          name: object_name,
-          transport_class: Transport.class_name_from_object_name(object_name),
-        }
-
-        data
-      end
-
-      def raise_precondition_error(error)
-        raise PDK::CLI::ExitWithError, _('%{error}: Creating a transport needs some local configuration in your module.' \
-          ' Please follow the docs at https://github.com/puppetlabs/puppet-resource_api#getting-started.') % { error: error }
-      end
-
-      def check_preconditions
-        super
-        # These preconditions can be removed once the pdk-templates are carrying the puppet-resource_api gem by default, and have switched
-        # the default mock_with value.
-        sync_path = PDK::Util.find_upwards('.sync.yml')
-        if sync_path.nil?
-          raise_precondition_error(_('.sync.yml not found'))
-        end
-        sync = YAML.load_file(sync_path)
-        if !sync.is_a? Hash
-          raise_precondition_error(_('.sync.yml contents is not a Hash'))
-        elsif !sync.key? 'Gemfile'
-          raise_precondition_error(_('Gemfile configuration not found'))
-        elsif !sync['Gemfile'].key? 'optional'
-          raise_precondition_error(_('Gemfile.optional configuration not found'))
-        elsif !sync['Gemfile']['optional'].key? ':development'
-          raise_precondition_error(_('Gemfile.optional.:development configuration not found'))
-        elsif sync['Gemfile']['optional'][':development'].none? { |g| g['gem'] == 'puppet-resource_api' }
-          raise_precondition_error(_('puppet-resource_api not found in the Gemfile config'))
-        elsif !sync.key? 'spec/spec_helper.rb'
-          raise_precondition_error(_('spec/spec_helper.rb configuration not found'))
-        elsif !sync['spec/spec_helper.rb'].key? 'mock_with'
-          raise_precondition_error(_('spec/spec_helper.rb.mock_with configuration not found'))
-        elsif !sync['spec/spec_helper.rb']['mock_with'] == ':rspec'
-          raise_precondition_error(_('spec/spec_helper.rb.mock_with not set to \':rspec\''))
-        end
-      end
-
-      # @return [String] the path where the new transport will be written.
-      def target_object_path
-        @target_object_path ||= File.join(module_dir, 'lib', 'puppet', 'transport', object_name) + '.rb'
+    class Transport < ResourceAPIObject
+      def friendly_name
+        'Resource API Transport'.freeze
       end
 
-      # @return [String] the path where the new schema will be written.
-      def target_type_path
-        @target_type_path ||= File.join(module_dir, 'lib', 'puppet', 'transport', 'schema', object_name) + '.rb'
-      end
-
-      # @return [String] the path where the deviceshim for the transport will be written.
-      def target_device_path
-        @target_device_path ||= File.join(module_dir, 'lib', 'puppet', 'util', 'network_device', object_name, 'device.rb')
-      end
-
-      # @return [String] the path where the tests for the new transport
-      # will be written.
-      def target_spec_path
-        @target_spec_path ||= File.join(module_dir, 'spec', 'unit', 'puppet', 'transport', object_name) + '_spec.rb'
-      end
-
-      # @return [String] the path where the tests for the new schema will be written.
-      def target_type_spec_path
-        @target_type_spec_path ||= File.join(module_dir, 'spec', 'unit', 'puppet', 'transport', 'schema', object_name) + '_spec.rb'
+      def template_files
+        # Note : Due to how the V1 templates work, the names of the source template files may be mismatched to
+        # their destination, e.g. transport_type.erb is really a transport schema
+        files = {
+          'transport_spec.erb'      => File.join('spec', 'unit', 'puppet', 'transport', object_name) + '_spec.rb',
+          'transport_type_spec.erb' => File.join('spec', 'unit', 'puppet', 'transport', 'schema', object_name) + '_spec.rb',
+        }
+        return files if spec_only?
+        files.merge(
+          'transport.erb' => File.join('lib', 'puppet', 'transport', object_name) + '.rb',
+          'transport_device.erb'    => File.join('lib', 'puppet', 'util', 'network_device', object_name, 'device.rb'),
+          'transport_type.erb'      => File.join('lib', 'puppet', 'transport', 'schema', object_name) + '.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
+      def template_data
+        {
+          name: object_name,
+          transport_class: class_name_from_object_name(object_name),
+        }
       end
     end
   end

data/lib/pdk/generate.rb

@@ -7,6 +7,7 @@ module PDK
     autoload :Provider, 'pdk/generate/provider'
     autoload :PuppetClass, 'pdk/generate/puppet_class'
     autoload :PuppetObject, 'pdk/generate/puppet_object'
+    autoload :ResourceAPIObject, 'pdk/generate/resource_api_object'
     autoload :Task, 'pdk/generate/task'
     autoload :Transport, 'pdk/generate/transport'
 

data/lib/pdk/module/convert.rb

@@ -26,6 +26,7 @@ module PDK
         unless update_manager.changes?
           if adding_tests?
             add_tests!
+            print_result 'Convert completed'
           else
             require 'pdk/report'
 
@@ -53,18 +54,15 @@ module PDK
           return unless continue
         end
 
-        # Remove these files straight away as these changes are not something that the user needs to review.
-        if needs_bundle_update?
-          update_manager.unlink_file('Gemfile.lock')
-          update_manager.unlink_file(File.join('.bundle', 'config'))
-        end
+        # Remove these files straight away as these changes are not something
+        # that the user needs to review.
+        update_manager.unlink_file('Gemfile.lock')
+        update_manager.unlink_file(File.join('.bundle', 'config'))
 
         update_manager.sync_changes!
 
-        if needs_bundle_update?
-          require 'pdk/util/bundler'
-          PDK::Util::Bundler.ensure_bundle!
-        end
+        require 'pdk/util/bundler'
+        PDK::Util::Bundler.ensure_bundle!
 
         add_tests! if adding_tests?
 
@@ -88,41 +86,59 @@ module PDK
       end
 
       def missing_tests?
-        test_generators.any? { |gen| gen.can_run? }
+        !available_test_generators.empty?
+      end
+
+      def available_test_generators
+        # Only select generators which can run and have no pre-existing files
+        test_generators.select do |gen|
+          if gen.can_run?
+            gen.template_files.none? { |_, dst_path| PDK::Util::Filesystem.exist?(File.join(gen.context.root_path, dst_path)) }
+          else
+            false
+          end
+        end
       end
 
-      def test_generators
+      def test_generators(context = PDK.context)
         return @test_generators unless @test_generators.nil?
         require 'pdk/util/puppet_strings'
 
         test_gens = PDK::Util::PuppetStrings.all_objects.map do |generator, objects|
           (objects || []).map do |obj|
-            generator.new(module_dir, obj['name'], spec_only: true)
+            generator.new(context, obj['name'], spec_only: true)
           end
         end
 
         @test_generators = test_gens.flatten
       end
 
-      def add_tests!
-        test_generators.each do |gen|
-          gen.run if gen.can_run?
+      def stage_tests!(manager)
+        available_test_generators.each do |gen|
+          gen.stage_changes(manager)
         end
+        manager
       end
 
-      def needs_bundle_update?
-        update_manager.changed?('Gemfile')
+      def add_tests!
+        update_manager.clear!
+        stage_tests!(update_manager)
+
+        if update_manager.changes?
+          update_manager.sync_changes!
+          print_summary
+        else
+          PDK::Report.default_target.puts(_('No test changes required.'))
+        end
       end
 
-      def stage_changes!
+      def stage_changes!(context = PDK.context)
         require 'pdk/util/filesystem'
 
         metadata_path = File.join(module_dir, 'metadata.json')
 
-        PDK::Module::TemplateDir.with(template_uri, nil, true) do |templates|
-          new_metadata = update_metadata(metadata_path, templates.metadata)
-          templates.module_metadata = new_metadata.data unless new_metadata.nil?
-
+        PDK::Template.with(template_uri, context) do |template_dir|
+          new_metadata = update_metadata(metadata_path, template_dir.metadata)
           if options[:noop] && new_metadata.nil?
             update_manager.add_file(metadata_path, '')
           elsif PDK::Util::Filesystem.file?(metadata_path)
@@ -131,7 +147,9 @@ module PDK
             update_manager.add_file(metadata_path, new_metadata.to_json)
           end
 
-          templates.render do |relative_file_path, file_content, file_status|
+          # new_metadata == nil when creating a new module but with --noop@
+          module_name = new_metadata.nil? ? 'new-module' : new_metadata.data['name']
+          template_dir.render_new_module(module_name) do |relative_file_path, file_content, file_status|
             absolute_file_path = File.join(module_dir, relative_file_path)
             case file_status
             when :unmanage

data/lib/pdk/module/release.rb

@@ -111,7 +111,7 @@ module PDK
 
         PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
 
-        validator_exit_code, = PDK::Validate.invoke_validators_by_name(PDK::Validate.validator_names, false, options)
+        validator_exit_code, = PDK::Validate.invoke_validators_by_name(PDK.context, PDK::Validate.validator_names, false, options)
         raise PDK::CLI::ExitWithError, _('An error occured during validation') unless validator_exit_code.zero?
       end
 

data/lib/pdk/module/update.rb

@@ -33,19 +33,15 @@ module PDK
           return unless PDK::CLI::Util.prompt_for_yes(message)
         end
 
-        # Remove these files straight away as these changes are not something that the user needs to review.
-        if needs_bundle_update?
-          update_manager.unlink_file('Gemfile.lock')
-          update_manager.unlink_file(File.join('.bundle', 'config'))
-        end
+        # Remove these files straight away as these changes are not something
+        # that the user needs to review.
+        update_manager.unlink_file('Gemfile.lock')
+        update_manager.unlink_file(File.join('.bundle', 'config'))
 
         update_manager.sync_changes!
 
-        if needs_bundle_update?
-          require 'pdk/util/bundler'
-
-          PDK::Util::Bundler.ensure_bundle!
-        end
+        require 'pdk/util/bundler'
+        PDK::Util::Bundler.ensure_bundle!
 
         print_result 'Update completed'
       end

data/lib/pdk/module/update_manager.rb

@@ -75,6 +75,13 @@ module PDK
           changes[:modified].key?(path)
       end
 
+      def clear!
+        @modified_files.clear
+        @added_files.clear
+        @removed_files.clear
+        nil
+      end
+
       # Apply any pending changes stored in the UpdateManager to the module.
       #
       # @raise (see #calculate_diffs)

data/lib/pdk/module.rb

@@ -4,7 +4,6 @@ module PDK
     autoload :Convert, 'pdk/module/convert'
     autoload :Metadata, 'pdk/module/metadata'
     autoload :Release, 'pdk/module/release'
-    autoload :TemplateDir, 'pdk/module/template_dir'
     autoload :UpdateManager, 'pdk/module/update_manager'
     autoload :Update, 'pdk/module/update'
 

data/lib/pdk/template/fetcher/git.rb

@@ -0,0 +1,85 @@
+require 'pdk'
+
+module PDK
+  module Template
+    module Fetcher
+      class Git < PDK::Template::Fetcher::AbstractFetcher
+        # Whether the passed uri is fetchable by Git.
+        # @see PDK::Template::Fetcher.instance
+        # @return [Boolean]
+        def self.fetchable?(uri, _options = {})
+          PDK::Util::Git.repo?(uri.bare_uri)
+        end
+
+        # @see PDK::Template::Fetcher::AbstractTemplateFetcher.fetch!
+        def fetch!
+          return if fetched
+          super
+
+          # Default metadata for all git fetching methods
+          @metadata['template-url'] = uri.metadata_format
+
+          # We don't do a checkout of local-path repos. There are lots of edge
+          # cases or user un-expectations.
+          if PDK::Util::Git.work_tree?(uri.shell_path)
+            PDK.logger.warn _("Repository '%{repo}' has a work-tree; skipping git reset.") % {
+              repo: uri.shell_path,
+            }
+            @path = uri.shell_path
+            @temporary = false
+            @metadata['template-ref'] = describe_path_and_ref(@path)
+            return
+          end
+
+          # This is either a bare local repo or a remote. either way it needs cloning.
+          # A "remote" can also be git repo on the local filsystem.
+          # @todo When switching this over to using rugged, cache the cloned
+          # template repo in `%AppData%` or `$XDG_CACHE_DIR` and update before
+          # use.
+          require 'pdk/util'
+          require 'pdk/util/git'
+
+          temp_dir = PDK::Util.make_tmpdir_name('pdk-templates')
+          @temporary = true
+          origin_repo = uri.bare_uri
+          git_ref = uri.uri_fragment
+
+          # Clone the repository
+          clone_result = PDK::Util::Git.git('clone', origin_repo, temp_dir)
+          unless clone_result[:exit_code].zero?
+            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
+          @path = PDK::Util.canonical_path(temp_dir)
+
+          # Checkout the git reference
+          if PDK::Util::Git.work_dir_clean?(temp_dir)
+            Dir.chdir(temp_dir) do
+              full_ref = PDK::Util::Git.ls_remote(temp_dir, git_ref)
+              @metadata['template-ref'] = describe_path_and_ref(temp_dir, full_ref)
+              reset_result = PDK::Util::Git.git('reset', '--hard', full_ref)
+              return if reset_result[:exit_code].zero?
+
+              PDK.logger.error reset_result[:stdout]
+              PDK.logger.error reset_result[:stderr]
+              raise PDK::CLI::FatalError, _("Unable to checkout '%{ref}' of git repository at '%{path}'.") % { ref: git_ref, path: temp_dir }
+            end
+          else
+            PDK.logger.warn _("Uncommitted changes found when attempting to checkout '%{ref}' of git repository at '%{path}'; skipping git reset.") % { ref: git_ref, path: temp_dir }
+            @metadata['template-ref'] = describe_path_and_ref(temp_dir)
+          end
+        end
+
+        private
+
+        #:nocov: This is a just a wrapper for another method
+        def describe_path_and_ref(path, ref = nil)
+          require 'pdk/util/git'
+          PDK::Util::Git.describe(File.join(path, '.git'), ref)
+        end
+        #:nocov:
+      end
+    end
+  end
+end

data/lib/pdk/template/fetcher/local.rb

@@ -0,0 +1,28 @@
+require 'pdk'
+
+module PDK
+  module Template
+    module Fetcher
+      class Local < PDK::Template::Fetcher::AbstractFetcher
+        # Whether the passed uri is fetchable. This is a catch-all and all URIs
+        # are considered on-disk already.
+        #
+        # @see PDK::Template::Fetcher.instance
+        # @return [Boolean]
+        def self.fetchable?(_uri, _options = {})
+          true
+        end
+
+        # @see PDK::Template::Fetcher::AbstractTemplateFetcher.fetch!
+        def fetch!
+          return if fetched
+          super
+
+          @path = uri.shell_path
+          @temporary = false
+          @metadata['template-url'] = uri.bare_uri
+        end
+      end
+    end
+  end
+end

data/lib/pdk/template/fetcher.rb

@@ -0,0 +1,98 @@
+require 'pdk'
+
+module PDK
+  module Template
+    module Fetcher
+      autoload :Git, 'pdk/template/fetcher/git'
+      autoload :Local, 'pdk/template/fetcher/local'
+
+      # Returns a Template Fetcher implementation for the given Template URI
+      # @param uri [PDK::Util::TemplateURI] The URI of the template to fetch
+      # @param options [Hash{Object => Object}] A list of options to pass through to the fetcher.
+      #
+      # @return [PDK::Template::Fetcher::AbstractTemplateFetcher] An instance of a class which implements the AbstractFetcher class
+      def self.instance(uri, options = {})
+        return Git.new(uri, options) if Git.fetchable?(uri, options)
+        Local.new(uri, options)
+      end
+
+      # Creates an instance of a PDK::Template::Fetcher::AbstractTemplateFetcher object with the path or URL to the template
+      # and the block of code to run to be run while the template is fetched.
+      #
+      # The fetched directory is only guaranteed to be available on disk
+      # within the scope of the block passed to this method.
+      #
+      # @param uri [PDK::Util::TemplateURI] The URI of the template to fetch.
+      # @param options [Hash{Object => Object}] A list of options to pass through to the fetcher.
+      #
+      # @yieldparam fetcher [PDK::Template::Fetcher::AbstractTemplateFetcher] The initialised fetcher with
+      #             the template already fetched
+      #
+      # @example Using a git repository as a template
+      #   PDK::Template::Fetcher.with('https://github.com/puppetlabs/pdk-templates') do |fetcher|
+      #   end
+      #
+      # @raise [ArgumentError] If no block is given to this method.
+      # @return [void]
+      def self.with(uri, options = {})
+        raise ArgumentError, _('%{class_name}.with must be passed a block.') % { class_name: name } unless block_given?
+        fetcher = instance(uri, options)
+
+        begin
+          fetcher.fetch!
+          yield fetcher
+        ensure
+          # If the the path is temporary, clean it up
+          PDK::Util::Filesystem.rm_rf(fetcher.path) if fetcher.temporary
+        end
+        nil
+      end
+
+      # An abstract class which all Template Fetchers should subclass. This class is responsible for
+      # downloading or copying a Template Directory that is pointed to by a Template URI
+      #
+      # @api private
+      # @abstract
+      class AbstractFetcher
+        # @return [PDK::Util::TemplateURI] The URI of the template that is to be fetched
+        attr_reader :uri
+
+        # @return [String] The local filesystem path of the fetched template
+        attr_reader :path
+
+        # @return [Boolean] Whether the fetched path should be considered temporary and be deleted after use
+        attr_reader :temporary
+
+        # @return [Boolean] Whether the template has been fetched yet
+        attr_reader :fetched
+
+        # @return [Hash] The metadata hash for this template.
+        attr_reader :metadata
+
+        # @param uri [PDK::Util::TemplateURI] The URI of the template to fetch
+        # @param options [Hash{Object => Object}] A list of options to pass through to the fetcher.
+        def initialize(uri, options)
+          @uri = uri
+          # Defaults
+          @path = nil
+          @metadata = {
+            'pdk-version' => PDK::Util::Version.version_string,
+            'template-url' => nil,
+            'template-ref' => nil,
+          }
+          @fetched = false
+          @temporary = false
+          @options = options
+        end
+
+        # Fetches the template directory and populates the path property
+        #
+        # @return [void]
+        # @abstract
+        def fetch!
+          @fetched = true
+        end
+      end
+    end
+  end
+end