pdk 1.9.0 → 3.2.0

data/lib/pdk/report/event.rb

@@ -1,5 +1,4 @@
-require 'rexml/document'
-require 'pathname'
+require 'pdk'
 
 module PDK
   class Report
@@ -54,7 +53,7 @@ module PDK
       # @raise [ArgumentError] (see #sanitise_data)
       def initialize(data)
         sanitise_data(data).each do |key, value|
-          instance_variable_set("@#{key}", value)
+          instance_variable_set(:"@#{key}", value)
         end
       end
 
@@ -99,7 +98,7 @@ module PDK
       #   results.
       def rspec_puppet_coverage?
         @rspec_puppet_coverage_pattern ||= File.join('**', 'lib', 'rspec-puppet', 'coverage.rb')
-        source == 'rspec' && File.fnmatch?(@rspec_puppet_coverage_pattern, File.expand_path(file))
+        source == 'rspec' && PDK::Util::Filesystem.fnmatch?(@rspec_puppet_coverage_pattern, PDK::Util::Filesystem.expand_path(file))
       end
 
       # Renders the event in a clang style text format.
@@ -112,8 +111,8 @@ module PDK
         location = nil if location.empty?
 
         # TODO: maybe add trace
-        header = [severity, source, location, message].compact.join(': ')
         if source == 'rspec'
+          header = [severity, source, location, message].compact.join(': ')
           result = [header, "  #{test}"]
           context = context_lines
           unless context.nil?
@@ -124,7 +123,13 @@ module PDK
 
           result.compact.join("\n")
         else
-          header
+          output = ['pdk']
+          output << "(#{severity.upcase}):" unless severity.nil?
+          output << "#{source}:" unless source.nil?
+          output << message unless message.nil?
+          output << "(#{location})" unless location.nil?
+
+          output.join(' ')
         end
       end
 
@@ -132,6 +137,8 @@ module PDK
       #
       # @return [REXML::Element] The rendered event.
       def to_junit
+        require 'rexml/document'
+
         testcase = REXML::Element.new('testcase')
         testcase.attributes['classname'] = [source, test].compact.join('.')
         testcase.attributes['name'] = [file, line, column].compact.join(':')
@@ -187,13 +194,12 @@ module PDK
       # @raise [ArgumentError] if the value is nil, an empty String, or not
       #   a String.
       def sanitise_file(value)
-        if value.nil? || (value.is_a?(String) && value.empty?)
-          raise ArgumentError, _('File not specified.')
-        end
+        raise ArgumentError, 'File not specified.' if value.nil? || (value.is_a?(String) && value.empty?)
 
-        unless value.is_a?(String)
-          raise ArgumentError, _('File must be a String.')
-        end
+        raise ArgumentError, 'File must be a String.' unless value.is_a?(String)
+
+        require 'pathname'
+        require 'pdk/util'
 
         path = Pathname.new(value)
 
@@ -224,22 +230,13 @@ module PDK
       # @raise [ArgumentError] if the value is nil, an empty String, or not
       #   a String or Symbol representation of a valid state.
       def sanitise_state(value)
-        if value.nil? || (value.is_a?(String) && value.empty?)
-          raise ArgumentError, _('State not specified.')
-        end
+        raise ArgumentError, 'State not specified.' if value.nil? || (value.is_a?(String) && value.empty?)
 
         value = value.to_sym if value.is_a?(String)
-        unless value.is_a?(Symbol)
-          raise ArgumentError, _('State must be a Symbol, not %{type}') % { type: value.class }
-        end
+        raise ArgumentError, format('State must be a Symbol, not %{type}', type: value.class) unless value.is_a?(Symbol)
 
         valid_states = [:passed, :error, :failure, :skipped]
-        unless valid_states.include?(value)
-          raise ArgumentError, _('Invalid state %{state}. Valid states are: %{valid}.') % {
-            state: value.inspect,
-            valid: valid_states.map(&:inspect).join(', '),
-          }
-        end
+        raise ArgumentError, format('Invalid state %{state}. Valid states are: %{valid}.', state: value.inspect, valid: valid_states.map(&:inspect).join(', ')) unless valid_states.include?(value)
 
         value
       end
@@ -253,9 +250,7 @@ module PDK
       #
       # @raise [ArgumentError] if the value is nil or an empty String.
       def sanitise_source(value)
-        if value.nil? || (value.is_a?(String) && value.empty?)
-          raise ArgumentError, _('Source not specified.')
-        end
+        raise ArgumentError, 'Source not specified.' if value.nil? || (value.is_a?(String) && value.empty?)
 
         value.to_s
       end
@@ -267,20 +262,16 @@ module PDK
       # @return [Integer] the provided value, converted into an Integer if
       #   necessary.
       def sanitise_line(value)
-        return nil if value.nil?
+        return if value.nil?
 
         valid_types = [String, Integer]
         if RUBY_VERSION.split('.')[0..1].join('.').to_f < 2.4
           valid_types << Fixnum # rubocop:disable Lint/UnifiedInteger
         end
 
-        unless valid_types.include?(value.class)
-          raise ArgumentError, _('Line must be an Integer or a String representation of an Integer.')
-        end
+        raise ArgumentError, 'Line must be an Integer or a String representation of an Integer.' unless valid_types.include?(value.class)
 
-        if value.is_a?(String) && value !~ %r{\A[0-9]+\Z}
-          raise ArgumentError, _('The line number can contain only the digits 0-9.')
-        end
+        raise ArgumentError, 'The line number can contain only the digits 0-9.' if value.is_a?(String) && value !~ /\A[0-9]+\Z/
 
         value.to_i
       end
@@ -292,20 +283,16 @@ module PDK
       # @return [Integer] the provided value, converted into an Integer if
       #   necessary.
       def sanitise_column(value)
-        return nil if value.nil?
+        return if value.nil?
 
         valid_types = [String, Integer]
         if RUBY_VERSION.split('.')[0..1].join('.').to_f < 2.4
           valid_types << Fixnum # rubocop:disable Lint/UnifiedInteger
         end
 
-        unless valid_types.include?(value.class)
-          raise ArgumentError, _('Column must be an Integer or a String representation of an Integer.')
-        end
+        raise ArgumentError, 'Column must be an Integer or a String representation of an Integer.' unless valid_types.include?(value.class)
 
-        if value.is_a?(String) && value !~ %r{\A[0-9]+\Z}
-          raise ArgumentError, _('The column number can contain only the digits 0-9.')
-        end
+        raise ArgumentError, 'The column number can contain only the digits 0-9.' if value.is_a?(String) && value !~ /\A[0-9]+\Z/
 
         value.to_i
       end
@@ -317,18 +304,16 @@ module PDK
       #
       # @return [Array] Array of stack trace lines with less relevant lines excluded
       def sanitise_trace(value)
-        return nil if value.nil?
+        return if value.nil?
 
         valid_types = [Array]
 
-        unless valid_types.include?(value.class)
-          raise ArgumentError, _('Trace must be an Array of stack trace lines.')
-        end
+        raise ArgumentError, 'Trace must be an Array of stack trace lines.' unless valid_types.include?(value.class)
 
         # Drop any stacktrace lines that include '/gems/' in the path or
         # are the original rspec binstub lines
         value.reject do |line|
-          (line =~ %r{/gems/}) || (line =~ %r{bin/rspec:})
+          line.include?('/gems/') || line.include?('bin/rspec:')
         end
       end
 
@@ -342,10 +327,13 @@ module PDK
       def context_lines(max_num_lines = 5)
         return if file.nil? || line.nil?
 
-        file_path = [file, File.join(PDK::Util.module_root, file)].find { |r| File.file?(r) }
+        file_path = [file, File.join(PDK::Util.module_root, file)].find do |path|
+          PDK::Util::Filesystem.file?(path)
+        end
+
         return if file_path.nil?
 
-        file_content = File.read(file_path).split("\n")
+        file_content = PDK::Util::Filesystem.read_file(file_path).split("\n")
         delta = (max_num_lines - 1) / 2
         min = [0, (line - 1) - delta].max
         max = [(line - 1) + delta, file_content.length].min

data/lib/pdk/report.rb

@@ -1,13 +1,12 @@
-require 'rexml/document'
-require 'time'
-require 'pdk/report/event'
-require 'socket'
+require 'pdk'
 
 module PDK
   class Report
+    autoload :Event, 'pdk/report/event'
+
     # @return [Array<String>] the list of supported report formats.
     def self.formats
-      @report_formats ||= %w[junit text].freeze
+      @report_formats ||= ['junit', 'text'].freeze
     end
 
     # @return [Symbol] the method name of the default report format.
@@ -48,8 +47,9 @@ module PDK
     # @param target [#write] an IO object that the report will be written to.
     #   Defaults to PDK::Report.default_target.
     def write_junit(target = self.class.default_target)
-      # Open a File Object for IO if target is a string containing a filename or path
-      target = File.open(target, 'w') if target.is_a? String
+      require 'rexml/document'
+      require 'time'
+      require 'socket'
 
       document = REXML::Document.new
       document << REXML::XMLDecl.new
@@ -60,9 +60,9 @@ module PDK
         testsuite = REXML::Element.new('testsuite')
         testsuite.attributes['name'] = testsuite_name
         testsuite.attributes['tests'] = testcases.length
-        testsuite.attributes['errors'] = testcases.select(&:error?).length
-        testsuite.attributes['failures'] = testcases.select(&:failure?).length
-        testsuite.attributes['skipped'] = testcases.select(&:skipped?).length
+        testsuite.attributes['errors'] = testcases.count(&:error?)
+        testsuite.attributes['failures'] = testcases.count(&:failure?)
+        testsuite.attributes['skipped'] = testcases.count(&:skipped?)
         testsuite.attributes['time'] = 0
         testsuite.attributes['timestamp'] = Time.now.strftime('%Y-%m-%dT%H:%M:%S')
         testsuite.attributes['hostname'] = Socket.gethostname
@@ -78,9 +78,14 @@ module PDK
       end
 
       document.elements << testsuites
-      document.write(target, 2)
-    ensure
-      target.close if target.is_a? File
+      report = ''
+      document.write(report, 2)
+
+      if target.is_a?(String)
+        PDK::Util::Filesystem.write_file(target, report)
+      else
+        target << report
+      end
     end
 
     # Renders the report as plain text.
@@ -88,25 +93,33 @@ module PDK
     # This report is designed for interactive use by a human and so excludes
     # all passing events in order to be consise.
     #
-    # @param target [#write] an IO object that the report will be written to.
-    #   Defaults to PDK::Report.default_target.
+    # @param target [String, IO] The IO target to write the report to.
+    #   If a String is provided, the report will be written to a file with the given path.
+    #   If an IO object is provided, the report will be written to the IO object.
+    #   If no target is provided, the default target PDK::Report.default_target will be used.
+    #
+    # @return [void]
     def write_text(target = self.class.default_target)
-      # Open a File Object for IO if target is a string containing a filename or path
-      target = File.open(target, 'w') if target.is_a? String
       coverage_report = nil
+      report = []
 
-      events.each do |_tool, tool_events|
+      events.each_value do |tool_events|
         tool_events.each do |event|
           if event.rspec_puppet_coverage?
             coverage_report = event.to_text
           else
-            target.puts(event.to_text) unless event.pass?
+            report << event.to_text unless event.pass? || event.skipped?
           end
         end
       end
-    ensure
-      target.puts "\n#{coverage_report}" if coverage_report
-      target.close if target.is_a? File
+
+      report << "\n#{coverage_report}" if coverage_report
+
+      if target.is_a?(String)
+        PDK::Util::Filesystem.write_file(target, report.join("\n"))
+      elsif !report.empty?
+        target << report.join("\n") << "\n"
+      end
     end
   end
 end

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

@@ -0,0 +1,84 @@
+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 format("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, format("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, format("Unable to checkout '%{ref}' of git repository at '%{path}'.", ref: git_ref, path: temp_dir)
+            end
+          else
+            PDK.logger.warn format("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,29 @@
+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,100 @@
+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, format('%{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

data/lib/pdk/template/renderer/v1/legacy_template_dir.rb

@@ -0,0 +1,108 @@
+require 'pdk'
+
+module PDK
+  module Template
+    module Renderer
+      module V1
+        # The old templating code in the PDK passed through a TemplateDir object. This class mimics the methods
+        # of that old class so that existing custom templates will still function with the newer refactor templating code.
+        # Methods which have no use in custom templates exist but do no nothing, for example `def render; end`
+        #
+        # @see https://raw.githubusercontent.com/puppetlabs/pdk/4ffd58062c77ad1e54d2fe16b16015f7207bcee8/lib/pdk/module/template_dir/base.rb
+        # :nocov: This class is tested in the packaging and acceptance testing suites
+        class LegacyTemplateDir
+          attr_accessor :module_metadata
+          attr_reader :uri
+
+          def initialize(context, uri, path, module_metadata = {})
+            @uri = uri
+            @module_metadata = module_metadata
+            @context = context
+            @path = path
+          end
+
+          def metadata; end
+
+          def render; end
+
+          def object_template_for; end
+
+          def object_config
+            config_for(nil)
+          end
+
+          # Generate a hash of data to be used when rendering the specified
+          # template.
+          #
+          # @param dest_path [String] The destination path of the file that the
+          # data is for, relative to the root of the module.
+          #
+          # @return [Hash] The data that will be available to the template via the
+          # `@configs` instance variable.
+          #
+          # @api private
+          def config_for(dest_path, sync_config_path = nil)
+            require 'pdk/util'
+
+            module_root = PDK::Util.module_root
+            sync_config_path ||= File.join(module_root, '.sync.yml') unless module_root.nil?
+            config_path = File.join(@path, 'config_defaults.yml')
+
+            if @config.nil?
+              require 'deep_merge'
+              conf_defaults = read_config(config_path)
+              @sync_config = read_config(sync_config_path) unless sync_config_path.nil?
+              @config = conf_defaults
+              @config.deep_merge!(@sync_config, knockout_prefix: '---') unless @sync_config.nil?
+            end
+            file_config = @config.fetch('common', {}).clone
+            file_config['module_metadata'] = @module_metadata
+            file_config.merge!(@config.fetch(dest_path, {})) unless dest_path.nil?
+            file_config.merge!(@config).tap do |c|
+              if uri.default?
+                if c['unmanaged']
+                  'unmanaged'
+                elsif c['delete']
+                  'deleted'
+                elsif @sync_config&.key?(dest_path)
+                  'customized'
+                else
+                  'default'
+                end
+              end
+            end
+          end
+
+          # Generates a hash of data from a given yaml file location.
+          #
+          # @param loc [String] The path of the yaml config file.
+          #
+          # @warn If the specified path is not a valid yaml file. Returns an empty Hash
+          # if so.
+          #
+          # @return [Hash] The data that has been read in from the given yaml file.
+          #
+          # @api private
+          def read_config(loc)
+            if PDK::Util::Filesystem.file?(loc) && PDK::Util::Filesystem.readable?(loc)
+              require 'yaml'
+
+              begin
+                YAML.safe_load(PDK::Util::Filesystem.read_file(loc), permitted_classes: [], permitted_symbols: [], aliases: true)
+              rescue Psych::SyntaxError => e
+                PDK.logger.warn format("'%{file}' is not a valid YAML file: %{problem} %{context} at line %{line} column %{column}", file: loc, problem: e.problem, context: e.context, line: e.line,
+                                                                                                                                     column: e.column)
+                {}
+              end
+            else
+              {}
+            end
+          end
+
+          def template_path(_uri); end
+        end
+        # :nocov:
+      end
+    end
+  end
+end