pdk 2.4.0 → 2.5.0

data/lib/pdk/report.rb

@@ -1,121 +1,121 @@
-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
-    end
-
-    # @return [Symbol] the method name of the default report format.
-    def self.default_format
-      :write_text
-    end
-
-    # @return [#write] the default target to write the report to.
-    def self.default_target
-      $stdout
-    end
-
-    # Memoised access to the report event storage hash.
-    #
-    # The keys of the Hash are the source names of the Events (see
-    # PDK::Report::Event#source).
-    #
-    # @example accessing events from the puppet-lint validator
-    #   report = PDK::Report.new
-    #   report.events['puppet-lint']
-    #
-    # @return [Hash{String=>Array<PDK::Report::Event>}] the events stored in
-    #   the repuort.
-    def events
-      @events ||= {}
-    end
-
-    # Create a new PDK::Report::Event from a hash of values and add it to the
-    # report.
-    #
-    # @param data [Hash] (see PDK::Report::Event#initialize)
-    def add_event(data)
-      (events[data[:source]] ||= []) << PDK::Report::Event.new(data)
-    end
-
-    # Renders the report as a JUnit XML document.
-    #
-    # @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)
-      require 'rexml/document'
-      require 'time'
-      require 'socket'
-
-      document = REXML::Document.new
-      document << REXML::XMLDecl.new
-      testsuites = REXML::Element.new('testsuites')
-
-      id = 0
-      events.each do |testsuite_name, testcases|
-        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['time'] = 0
-        testsuite.attributes['timestamp'] = Time.now.strftime('%Y-%m-%dT%H:%M:%S')
-        testsuite.attributes['hostname'] = Socket.gethostname
-        testsuite.attributes['id'] = id
-        testsuite.attributes['package'] = testsuite_name
-        testsuite.add_element('properties')
-        testcases.each { |r| testsuite.elements << r.to_junit }
-        testsuite.add_element('system-out')
-        testsuite.add_element('system-err')
-
-        testsuites.elements << testsuite
-        id += 1
-      end
-
-      document.elements << testsuites
-      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.
-    #
-    # 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.
-    def write_text(target = self.class.default_target)
-      coverage_report = nil
-      report = []
-
-      events.each do |_tool, tool_events|
-        tool_events.each do |event|
-          if event.rspec_puppet_coverage?
-            coverage_report = event.to_text
-          else
-            report << event.to_text unless event.pass? || event.skipped?
-          end
-        end
-      end
-
-      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
+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
+    end
+
+    # @return [Symbol] the method name of the default report format.
+    def self.default_format
+      :write_text
+    end
+
+    # @return [#write] the default target to write the report to.
+    def self.default_target
+      $stdout
+    end
+
+    # Memoised access to the report event storage hash.
+    #
+    # The keys of the Hash are the source names of the Events (see
+    # PDK::Report::Event#source).
+    #
+    # @example accessing events from the puppet-lint validator
+    #   report = PDK::Report.new
+    #   report.events['puppet-lint']
+    #
+    # @return [Hash{String=>Array<PDK::Report::Event>}] the events stored in
+    #   the repuort.
+    def events
+      @events ||= {}
+    end
+
+    # Create a new PDK::Report::Event from a hash of values and add it to the
+    # report.
+    #
+    # @param data [Hash] (see PDK::Report::Event#initialize)
+    def add_event(data)
+      (events[data[:source]] ||= []) << PDK::Report::Event.new(data)
+    end
+
+    # Renders the report as a JUnit XML document.
+    #
+    # @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)
+      require 'rexml/document'
+      require 'time'
+      require 'socket'
+
+      document = REXML::Document.new
+      document << REXML::XMLDecl.new
+      testsuites = REXML::Element.new('testsuites')
+
+      id = 0
+      events.each do |testsuite_name, testcases|
+        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['time'] = 0
+        testsuite.attributes['timestamp'] = Time.now.strftime('%Y-%m-%dT%H:%M:%S')
+        testsuite.attributes['hostname'] = Socket.gethostname
+        testsuite.attributes['id'] = id
+        testsuite.attributes['package'] = testsuite_name
+        testsuite.add_element('properties')
+        testcases.each { |r| testsuite.elements << r.to_junit }
+        testsuite.add_element('system-out')
+        testsuite.add_element('system-err')
+
+        testsuites.elements << testsuite
+        id += 1
+      end
+
+      document.elements << testsuites
+      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.
+    #
+    # 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.
+    def write_text(target = self.class.default_target)
+      coverage_report = nil
+      report = []
+
+      events.each do |_tool, tool_events|
+        tool_events.each do |event|
+          if event.rspec_puppet_coverage?
+            coverage_report = event.to_text
+          else
+            report << event.to_text unless event.pass? || event.skipped?
+          end
+        end
+      end
+
+      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

@@ -1,85 +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
+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

@@ -1,28 +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
+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

@@ -1,98 +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
+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