pdk 1.7.1 → 1.8.0

data/lib/pdk/util/filesystem.rb

@@ -0,0 +1,12 @@
+module PDK
+  module Util
+    module Filesystem
+      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)) }
+      end
+      module_function :write_file
+    end
+  end
+end

data/lib/pdk/util/puppet_version.rb

@@ -42,7 +42,14 @@ module PDK
       end
 
       def fetch_puppet_dev
+        # 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
+          end
+
           FileUtils.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?
@@ -52,12 +59,22 @@ module PDK
           raise PDK::CLI::FatalError, _("Unable to clone git repository at '%{repo}'.") % { repo: DEFAULT_PUPPET_DEV_URL }
         end
 
-        fetch_result = PDK::Util::Git.git('--git-dir', File.join(puppet_dev_path, '.git'), 'pull', '--ff-only')
-        return if fetch_result[:exit_code].zero?
+        # Fetch Updates from remote repository
+        fetch_result = PDK::Util::Git.git('-C', puppet_dev_path, 'fetch', 'origin')
+
+        unless fetch_result[:exit_code].zero?
+          PDK.logger.error fetch_result[:stdout]
+          PDK.logger.error fetch_result[:stderr]
+          raise PDK::CLI::FatalError, _("Unable to fetch from git remote at '%{repo}'.") % { repo: DEFAULT_PUPPET_DEV_URL }
+        end
+
+        # Reset local repo to latest
+        reset_result = PDK::Util::Git.git('-C', puppet_dev_path, 'reset', '--hard', 'origin/master')
+        return if reset_result[:exit_code].zero?
 
-        PDK.logger.error fetch_result[:stdout]
-        PDK.logger.error fetch_result[:stderr]
-        raise PDK::CLI::FatalError, _("Unable to pull updates for git repository at '%{cachedir}'.") % { repo: puppet_dev_path }
+        PDK.logger.error reset_result[:stdout]
+        PDK.logger.error reset_result[:stderr]
+        raise PDK::CLI::FatalError, _("Unable to update git repository at '%{cachedir}'.") % { repo: puppet_dev_path }
       end
 
       def find_gem_for(version_str)

data/lib/pdk/util/vendored_file.rb

@@ -2,6 +2,7 @@ require 'pdk/util'
 require 'net/https'
 require 'openssl'
 require 'fileutils'
+require 'pdk/util/filesystem'
 
 module PDK
   module Util
@@ -22,6 +23,8 @@ module PDK
       attr_reader :file_name
       attr_reader :url
 
+      include PDK::Util::Filesystem
+
       def initialize(file_name, url)
         @file_name = file_name
         @url = url
@@ -36,9 +39,7 @@ module PDK
         # TODO: should only write if it's valid JSON
         # TODO: need a way to invalidate if out of date
         FileUtils.mkdir_p(File.dirname(gem_vendored_path))
-        File.open(gem_vendored_path, 'w') do |fd|
-          fd.write(content)
-        end
+        write_file(gem_vendored_path, content)
         content
       end
 

data/lib/pdk/validate.rb

@@ -1,11 +1,12 @@
 require 'pdk/validate/metadata_validator'
 require 'pdk/validate/puppet_validator'
 require 'pdk/validate/ruby_validator'
+require 'pdk/validate/tasks_validator'
 
 module PDK
   module Validate
     def self.validators
-      @validators ||= [MetadataValidator, PuppetValidator, RubyValidator].freeze
+      @validators ||= [MetadataValidator, PuppetValidator, RubyValidator, TasksValidator].freeze
     end
 
     class ParseOutputError < StandardError; end

data/lib/pdk/validate/base_validator.rb

@@ -1,5 +1,6 @@
 require 'pdk'
 require 'pdk/cli/exec'
+require 'pdk/module'
 
 module PDK
   module Validate
@@ -12,6 +13,14 @@ module PDK
       #                 separately.
       INVOKE_STYLE = :once
 
+      # Controls how the validator behaves if not passed any targets.
+      #
+      #   true  - PDK will not pass the globbed targets to the validator command
+      #           and it will instead rely on the underlying tool to find its
+      #           own default targets.
+      #   false - PDK will pass the globbed targets to the validator command.
+      ALLOW_EMPTY_TARGETS = false
+
       def self.cmd_path
         File.join(PDK::Util.module_root, 'bin', cmd)
       end
@@ -30,13 +39,9 @@ module PDK
       def self.parse_targets(options)
         # If no targets are specified, then we will run validations from the
         # base module directory.
-        targets = if options[:targets].nil? || options[:targets].empty?
-                    [PDK::Util.module_root]
-                  else
-                    options[:targets]
-                  end
 
-        fixtures_pattern = File.join('**', 'spec', 'fixtures', '**', '*')
+        targets = options.fetch(:targets, []).empty? ? [PDK::Util.module_root] : options[:targets]
+
         targets.map! { |r| r.gsub(File::ALT_SEPARATOR, File::SEPARATOR) } if File::ALT_SEPARATOR
         skipped = []
         invalid = []
@@ -45,14 +50,16 @@ module PDK
             if File.directory?(target)
               target_root = PDK::Util.module_root
               pattern_glob = Array(pattern).map { |p| Dir.glob(File.join(target_root, p)) }
-              pattern_glob = pattern_glob.flatten.reject { |file| File.fnmatch(fixtures_pattern, file) }
 
-              target_list = pattern_glob.map do |file|
+              target_list = pattern_glob.flatten.map do |file|
                 if File.fnmatch(File.join(File.expand_path(target), '*'), file)
                   Pathname.new(file).relative_path_from(Pathname.new(PDK::Util.module_root)).to_s
                 end
               end
 
+              ignore_list = ignore_pathspec
+              target_list = target_list.reject { |file| ignore_list.match(file) }
+
               skipped << target if target_list.flatten.empty?
               target_list
             elsif File.file?(target)
@@ -75,6 +82,18 @@ module PDK
         [matched, skipped, invalid]
       end
 
+      def self.ignore_pathspec
+        ignore_pathspec = PDK::Module.default_ignored_pathspec.dup
+
+        if respond_to?(:pattern_ignore)
+          Array(pattern_ignore).each do |pattern|
+            ignore_pathspec.add(pattern)
+          end
+        end
+
+        ignore_pathspec
+      end
+
       def self.parse_options(_options, targets)
         targets
       end
@@ -109,6 +128,10 @@ module PDK
         end
       end
 
+      def self.allow_empty_targets?
+        self::ALLOW_EMPTY_TARGETS == true
+      end
+
       def self.invoke(report, options = {})
         targets, skipped, invalid = parse_targets(options)
 
@@ -132,6 +155,10 @@ module PDK
           options[:split_exec] = PDK::CLI::ExecGroup.new(spinner_text(targets), parallel: false)
         end
 
+        if options.fetch(:targets, []).empty? && allow_empty_targets?
+          targets = [[]]
+        end
+
         exit_codes = []
 
         targets.each do |invokation_targets|
@@ -140,6 +167,7 @@ module PDK
 
           command = PDK::CLI::Exec::Command.new(*cmd_argv).tap do |c|
             c.context = :module
+            c.environment = { 'PUPPET_GEM_VERSION' => options[:puppet] } if options[:puppet]
             unless options[:split_exec]
               exec_group = options[:exec_group]
               if exec_group

data/lib/pdk/validate/metadata_validator.rb

@@ -3,7 +3,6 @@ require 'pdk/cli/exec'
 require 'pdk/validate/base_validator'
 require 'pdk/validate/metadata/metadata_json_lint'
 require 'pdk/validate/metadata/metadata_syntax'
-require 'pdk/validate/metadata/task_metadata_lint'
 
 module PDK
   module Validate
@@ -13,7 +12,7 @@ module PDK
       end
 
       def self.metadata_validators
-        [MetadataSyntax, MetadataJSONLint, TaskMetadataLint]
+        [MetadataSyntax, MetadataJSONLint]
       end
 
       def self.invoke(report, options = {})

data/lib/pdk/validate/puppet/puppet_syntax.rb

@@ -37,6 +37,10 @@ module PDK
         '**/**.pp'
       end
 
+      def self.pattern_ignore
+        '/plans/**/*.pp'
+      end
+
       def self.spinner_text(_targets = nil)
         _('Checking Puppet manifest syntax (%{pattern}).') % { pattern: pattern }
       end

data/lib/pdk/validate/ruby/rubocop.rb

@@ -8,6 +8,8 @@ require 'pdk/validate/ruby_validator'
 module PDK
   module Validate
     class Rubocop < BaseValidator
+      ALLOW_EMPTY_TARGETS = true
+
       def self.name
         'rubocop'
       end

data/lib/pdk/validate/tasks/metadata_lint.rb

@@ -0,0 +1,126 @@
+require 'pdk'
+require 'pdk/cli/exec'
+require 'pdk/validate/base_validator'
+require 'pdk/util'
+require 'pathname'
+require 'json-schema'
+
+module PDK
+  module Validate
+    class Tasks
+      class MetadataLint < BaseValidator
+        FORGE_SCHEMA_URL = 'https://forgeapi.puppet.com/schemas/task.json'.freeze
+
+        def self.name
+          'task-metadata-lint'
+        end
+
+        def self.pattern
+          'tasks/*.json'
+        end
+
+        def self.spinner_text(_targets = [])
+          _('Checking task metadata style (%{targets}).') % {
+            targets: pattern,
+          }
+        end
+
+        def self.create_spinner(targets = [], options = {})
+          return unless PDK::CLI::Util.interactive?
+          options = options.merge(PDK::CLI::Util.spinner_opts_for_platform)
+
+          exec_group = options[:exec_group]
+          @spinner = if exec_group
+                       exec_group.add_spinner(spinner_text(targets), options)
+                     else
+                       TTY::Spinner.new("[:spinner] #{spinner_text(targets)}", options)
+                     end
+          @spinner.auto_spin
+        end
+
+        def self.stop_spinner(exit_code)
+          if exit_code.zero? && @spinner
+            @spinner.success
+          elsif @spinner
+            @spinner.error
+          end
+        end
+
+        def self.schema_file
+          schema = PDK::Util::VendoredFile.new('task.json', FORGE_SCHEMA_URL).read
+
+          JSON.parse(schema)
+        rescue PDK::Util::VendoredFile::DownloadError => e
+          raise PDK::CLI::FatalError, e.message
+        rescue JSON::ParserError
+          raise PDK::CLI::FatalError, _('Failed to parse Task Metadata Schema file.')
+        end
+
+        def self.invoke(report, options = {})
+          targets, skipped, invalid = parse_targets(options)
+
+          process_skipped(report, skipped)
+          process_invalid(report, invalid)
+
+          return 0 if targets.empty?
+
+          return_val = 0
+          create_spinner(targets, options)
+
+          targets.each do |target|
+            unless File.readable?(target)
+              report.add_event(
+                file:     target,
+                source:   name,
+                state:    :failure,
+                severity: 'error',
+                message:  _('Could not be read.'),
+              )
+              return_val = 1
+              next
+            end
+
+            begin
+              # Need to set the JSON Parser and State Generator to the Native one to be
+              # compatible with the multi_json adapter.
+              JSON.parser = JSON::Ext::Parser if defined?(JSON::Ext::Parser)
+              JSON.generator = JSON::Ext::Generator
+
+              begin
+                errors = JSON::Validator.fully_validate(schema_file, File.read(target)) || []
+              rescue JSON::Schema::SchemaError => e
+                raise PDK::CLI::FatalError, _('Unable to validate Task Metadata. %{error}.') % { error: e.message }
+              end
+
+              if errors.empty?
+                report.add_event(
+                  file:     target,
+                  source:   name,
+                  state:    :passed,
+                  severity: 'ok',
+                )
+              else
+                errors.each do |error|
+                  # strip off the trailing parts that aren't relevant
+                  error = error.split('in schema').first if error.include? 'in schema'
+
+                  report.add_event(
+                    file:     target,
+                    source:   name,
+                    state:    :failure,
+                    severity: 'error',
+                    message:  error,
+                  )
+                end
+                return_val = 1
+              end
+            end
+          end
+
+          stop_spinner(return_val)
+          return_val
+        end
+      end
+    end
+  end
+end

data/lib/pdk/validate/tasks/name.rb

@@ -0,0 +1,88 @@
+require 'pdk'
+require 'pdk/validate/base_validator'
+require 'pdk/util'
+
+module PDK
+  module Validate
+    class Tasks
+      class Name < BaseValidator
+        INVALID_TASK_MSG = _(
+          'Invalid task name. Task names must start with a lowercase letter' \
+          'and can only contain lowercase letters, numbers, and underscores.',
+        )
+
+        def self.name
+          'task-name'
+        end
+
+        def self.pattern
+          'tasks/**/*'
+        end
+
+        def self.spinner_text(_targets = [])
+          _('Checking task names (%{targets}).') % {
+            targets: pattern,
+          }
+        end
+
+        def self.create_spinner(targets = [], options = {})
+          return unless PDK::CLI::Util.interactive?
+          options = options.merge(PDK::CLI::Util.spinner_opts_for_platform)
+
+          exec_group = options[:exec_group]
+          @spinner = if exec_group
+                       exec_group.add_spinner(spinner_text(targets), options)
+                     else
+                       TTY::Spinner.new("[:spinner] #{spinner_text(targets)}", options)
+                     end
+          @spinner.auto_spin
+        end
+
+        def self.stop_spinner(exit_code)
+          if exit_code.zero? && @spinner
+            @spinner.success
+          elsif @spinner
+            @spinner.error
+          end
+        end
+
+        def self.invoke(report, options = {})
+          targets, skipped, invalid = parse_targets(options)
+
+          process_skipped(report, skipped)
+          process_invalid(report, invalid)
+
+          return 0 if targets.empty?
+
+          return_val = 0
+          create_spinner(targets, options)
+
+          targets.each do |target|
+            task_name = File.basename(target, File.extname(target))
+            if PDK::CLI::Util::OptionValidator.valid_task_name?(task_name)
+              report.add_event(
+                file:     target,
+                source:   name,
+                state:    :passed,
+                severity: 'ok',
+              )
+            else
+              report.add_event(
+                file:     target,
+                source:   name,
+                state:    :failure,
+                severity: 'error',
+                message:  INVALID_TASK_MSG,
+              )
+
+              return_val = 1
+            end
+          end
+
+          stop_spinner(return_val)
+          return_val
+        end
+      end
+    end
+  end
+end