pdk 1.14.1 → 1.15.0

data/lib/pdk/config.rb

@@ -47,7 +47,7 @@ module PDK
     end
 
     def self.bolt_analytics_config
-      file = File.expand_path('~/.puppetlabs/bolt/analytics.yaml')
+      file = PDK::Util::Filesystem.expand_path('~/.puppetlabs/bolt/analytics.yaml')
       PDK::Config::YAML.new(file: file)
     rescue PDK::Config::LoadError => e
       PDK.logger.debug _('Unable to load %{file}: %{message}') % {

data/lib/pdk/config/namespace.rb

@@ -27,7 +27,7 @@ module PDK
       #   used for settings which a randomly generated, instead of being deterministic, e.g. analytics user-id
       # @param block [Proc] a block that is evaluated within the new instance.
       def initialize(name = nil, file: nil, parent: nil, persistent_defaults: false, &block)
-        @file = File.expand_path(file) unless file.nil?
+        @file = PDK::Util::Filesystem.expand_path(file) unless file.nil?
         @settings = {}
         @name = name.to_s
         @parent = parent

data/lib/pdk/generate/module.rb

@@ -3,8 +3,6 @@ require 'pdk'
 module PDK
   module Generate
     class Module
-      extend PDK::Util::Filesystem
-
       def self.validate_options(opts)
         require 'pdk/cli/util/option_validator'
 
@@ -16,28 +14,26 @@ module PDK
           raise PDK::CLI::ExitWithError, error_msg
         end
 
-        target_dir = File.expand_path(opts[:target_dir])
-        raise PDK::CLI::ExitWithError, _("The destination directory '%{dir}' already exists") % { dir: target_dir } if File.exist?(target_dir)
+        target_dir = PDK::Util::Filesystem.expand_path(opts[:target_dir])
+        raise PDK::CLI::ExitWithError, _("The destination directory '%{dir}' already exists") % { dir: target_dir } if PDK::Util::Filesystem.exist?(target_dir)
       end
 
       def self.invoke(opts = {})
-        require 'pdk/module/templatedir'
         require 'pdk/util'
         require 'pdk/util/template_uri'
-        require 'fileutils'
         require 'pathname'
 
         validate_options(opts) unless opts[:module_name].nil?
 
         metadata = prepare_metadata(opts)
 
-        target_dir = File.expand_path(opts[:target_dir] || opts[:module_name])
+        target_dir = PDK::Util::Filesystem.expand_path(opts[:target_dir] || opts[:module_name])
         parent_dir = File.dirname(target_dir)
 
         begin
           test_file = File.join(parent_dir, '.pdk-test-writable')
-          write_file(test_file, 'This file was created by the Puppet Development Kit to test if this folder was writable, you can safely remove this file.')
-          FileUtils.rm_f(test_file)
+          PDK::Util::Filesystem.write_file(test_file, 'This file was created by the Puppet Development Kit to test if this folder was writable, you can safely remove this file.')
+          PDK::Util::Filesystem.rm_f(test_file)
         rescue Errno::EACCES
           raise PDK::CLI::FatalError, _("You do not have permission to write to '%{parent_dir}'") % {
             parent_dir: parent_dir,
@@ -51,12 +47,12 @@ module PDK
         template_uri = PDK::Util::TemplateURI.new(opts)
 
         begin
-          PDK::Module::TemplateDir.new(template_uri, metadata.data, true) do |templates|
+          PDK::Module::TemplateDir.with(template_uri, metadata.data, true) do |templates|
             templates.render do |file_path, file_content, file_status|
               next if file_status == :delete
               file = Pathname.new(temp_target_dir) + file_path
               file.dirname.mkpath
-              write_file(file, file_content)
+              PDK::Util::Filesystem.write_file(file, file_content)
             end
 
             # Add information about the template used to generate the module to the
@@ -83,7 +79,7 @@ module PDK
         end
 
         begin
-          if FileUtils.mv(temp_target_dir, target_dir)
+          if PDK::Util::Filesystem.mv(temp_target_dir, target_dir)
             unless opts[:'skip-bundle-install']
               Dir.chdir(target_dir) do
                 require 'pdk/util/bundler'
@@ -91,7 +87,7 @@ module PDK
               end
             end
 
-            PDK.logger.info _('Module \'%{name}\' generated at path \'%{path}\', from template \'%{url}\'.') % { name: opts[:module_name], path: target_dir, url: template_uri.git_remote }
+            PDK.logger.info _('Module \'%{name}\' generated at path \'%{path}\', from template \'%{url}\'.') % { name: opts[:module_name], path: target_dir, url: template_uri.bare_uri }
             PDK.logger.info(_('In your module directory, add classes with the \'pdk new class\' command.'))
           end
         rescue Errno::EACCES => e
@@ -139,8 +135,6 @@ module PDK
       end
 
       def self.prepare_module_directory(target_dir)
-        require 'fileutils'
-
         [
           File.join(target_dir, 'examples'),
           File.join(target_dir, 'files'),
@@ -149,7 +143,7 @@ module PDK
           File.join(target_dir, 'tasks'),
         ].each do |dir|
           begin
-            FileUtils.mkdir_p(dir)
+            PDK::Util::Filesystem.mkdir_p(dir)
           rescue SystemCallError => e
             raise PDK::CLI::FatalError, _("Unable to create directory '%{dir}': %{message}") % {
               dir:     dir,
@@ -269,7 +263,7 @@ module PDK
 
         interview.add_questions(questions)
 
-        if File.file?('metadata.json')
+        if PDK::Util::Filesystem.file?('metadata.json')
           puts _(
             "\nWe need to update the metadata.json file for this module, so we\'re going to ask you %{count} " \
             "questions.\n",

data/lib/pdk/generate/puppet_object.rb

@@ -260,7 +260,6 @@ module PDK
       # @api private
       def with_templates
         require 'pdk/logger'
-        require 'pdk/module/templatedir'
         require 'pdk/util/template_uri'
 
         templates.each do |template|
@@ -269,7 +268,7 @@ module PDK
             next
           end
 
-          PDK::Module::TemplateDir.new(PDK::Util::TemplateURI.new(template[:uri])) do |template_dir|
+          PDK::Module::TemplateDir.with(PDK::Util::TemplateURI.new(template[:uri])) do |template_dir|
             template_paths = template_dir.object_template_for(object_type)
 
             if template_paths

data/lib/pdk/generate/task.rb

@@ -54,7 +54,7 @@ module PDK
         error = _("A task named '%{name}' already exists in this module; defined in %{file}")
         allowed_extensions = %w[.md .conf]
 
-        Dir.glob(File.join(module_dir, 'tasks', "#{task_name}.*")).each do |file|
+        PDK::Util::Filesystem.glob(File.join(module_dir, 'tasks', "#{task_name}.*")).each do |file|
           next if allowed_extensions.include?(File.extname(file))
 
           raise PDK::CLI::ExitWithError, error % { name: task_name, file: file }

data/lib/pdk/module.rb

@@ -3,7 +3,8 @@ module PDK
     autoload :Build, 'pdk/module/build'
     autoload :Convert, 'pdk/module/convert'
     autoload :Metadata, 'pdk/module/metadata'
-    autoload :TemplateDir, 'pdk/module/templatedir'
+    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/module/build.rb

@@ -11,8 +11,8 @@ module PDK
       attr_reader :target_dir
 
       def initialize(options = {})
-        @module_dir = File.expand_path(options[:module_dir] || Dir.pwd)
-        @target_dir = File.expand_path(options[:'target-dir'] || File.join(module_dir, 'pkg'))
+        @module_dir = PDK::Util::Filesystem.expand_path(options[:module_dir] || Dir.pwd)
+        @target_dir = PDK::Util::Filesystem.expand_path(options[:'target-dir'] || File.join(module_dir, 'pkg'))
       end
 
       # Read and parse the values from metadata.json for the module that is
@@ -47,7 +47,7 @@ module PDK
       # Verify if there is an existing package in the target directory and prompts
       # the user if they want to overwrite it.
       def package_already_exists?
-        File.exist? package_file
+        PDK::Util::Filesystem.exist?(package_file)
       end
 
       # Check if the module is PDK Compatible. If not, then prompt the user if
@@ -67,20 +67,16 @@ module PDK
       #
       # If the directory already exists, remove it first.
       def create_build_dir
-        require 'fileutils'
-
         cleanup_build_dir
 
-        FileUtils.mkdir_p(build_dir)
+        PDK::Util::Filesystem.mkdir_p(build_dir)
       end
 
       # Remove the temporary build directory and all its contents from disk.
       #
       # @return nil.
       def cleanup_build_dir
-        require 'fileutils'
-
-        FileUtils.rm_rf(build_dir, secure: true)
+        PDK::Util::Filesystem.rm_rf(build_dir, secure: true)
       end
 
       # Combine the module name and version into a Forge-compatible dash
@@ -115,18 +111,17 @@ module PDK
       # @return nil.
       def stage_path(path)
         require 'pathname'
-        require 'fileutils'
 
         relative_path = Pathname.new(path).relative_path_from(Pathname.new(module_dir))
         dest_path = File.join(build_dir, relative_path)
 
-        if File.directory?(path)
-          FileUtils.mkdir_p(dest_path, mode: File.stat(path).mode)
-        elsif File.symlink?(path)
+        if PDK::Util::Filesystem.directory?(path)
+          PDK::Util::Filesystem.mkdir_p(dest_path, mode: PDK::Util::Filesystem.stat(path).mode)
+        elsif PDK::Util::Filesystem.symlink?(path)
           warn_symlink(path)
         else
           validate_ustar_path!(relative_path.to_path)
-          FileUtils.cp(path, dest_path, preserve: true)
+          PDK::Util::Filesystem.cp(path, dest_path, preserve: true)
         end
       rescue ArgumentError => e
         raise PDK::CLI::ExitWithError, _(
@@ -142,7 +137,7 @@ module PDK
       #
       # @return [Boolean] true if the path matches and should be ignored.
       def ignored_path?(path)
-        path = path.to_s + '/' if File.directory?(path)
+        path = path.to_s + '/' if PDK::Util::Filesystem.directory?(path)
 
         !ignored_files.match_paths([path], module_dir).empty?
       end
@@ -224,23 +219,22 @@ module PDK
       #
       # @return nil.
       def build_package
-        require 'fileutils'
         require 'zlib'
         require 'minitar'
         require 'find'
 
-        FileUtils.rm_f(package_file)
+        PDK::Util::Filesystem.rm_f(package_file)
 
         Dir.chdir(target_dir) do
           begin
-            gz = Zlib::GzipWriter.new(File.open(package_file, 'wb'))
+            gz = Zlib::GzipWriter.new(File.open(package_file, 'wb')) # rubocop:disable PDK/FileOpen
             tar = Minitar::Output.new(gz)
             Find.find(release_name) do |entry|
               entry_meta = {
                 name: entry,
               }
 
-              orig_mode = File.stat(entry).mode
+              orig_mode = PDK::Util::Filesystem.stat(entry).mode
               min_mode = Minitar.dir?(entry) ? 0o755 : 0o644
 
               entry_meta[:mode] = orig_mode | min_mode
@@ -272,7 +266,7 @@ module PDK
           File.join(module_dir, '.pdkignore'),
           File.join(module_dir, '.pmtignore'),
           File.join(module_dir, '.gitignore'),
-        ].find { |file| File.file?(file) && File.readable?(file) }
+        ].find { |file| PDK::Util::Filesystem.file?(file) && PDK::Util::Filesystem.readable?(file) }
       end
 
       # Instantiate a new PathSpec class and populate it with the pattern(s) of
@@ -288,11 +282,7 @@ module PDK
             ignored = if ignore_file.nil?
                         PathSpec.new
                       else
-                        fd = File.open(ignore_file, 'rb:UTF-8')
-                        data = fd.read
-                        fd.close
-
-                        PathSpec.new(data)
+                        PathSpec.new(PDK::Util::Filesystem.read_file(ignore_file, open_args: 'rb:UTF-8'))
                       end
 
             if File.realdirpath(target_dir).start_with?(File.realdirpath(module_dir))

data/lib/pdk/module/convert.rb

@@ -112,12 +112,11 @@ module PDK
       end
 
       def stage_changes!
-        require 'pdk/module/templatedir'
         require 'pdk/util/filesystem'
 
         metadata_path = 'metadata.json'
 
-        PDK::Module::TemplateDir.new(template_uri, nil, true) do |templates|
+        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?
 
@@ -251,13 +250,9 @@ module PDK
       def full_report(path)
         require 'pdk/report'
 
-        File.open(path, 'w') do |f|
-          f.write("/* Report generated by PDK at #{Time.now} */")
-          update_manager.changes[:modified].each do |_, diff|
-            f.write("\n\n\n" + diff)
-          end
-          f.write("\n")
-        end
+        report = ["/* Report generated by PDK at #{Time.now} */"]
+        report.concat(update_manager.changes[:modified].map { |_, diff| "\n\n\n#{diff}" })
+        PDK::Util::Filesystem.write_file(path, report.join)
         PDK::Report.default_target.puts(_("\nYou can find a report of differences in %{path}.\n\n") % { path: path })
       end
 

data/lib/pdk/module/metadata.rb

@@ -5,8 +5,6 @@ module PDK
     class Metadata
       attr_accessor :data
 
-      include PDK::Util::Filesystem
-
       OPERATING_SYSTEMS = {
         'RedHat based Linux' => [
           {
@@ -127,7 +125,7 @@ module PDK
       end
 
       def write!(path)
-        write_file(path, to_json)
+        PDK::Util::Filesystem.write_file(path, to_json)
       end
 
       def forge_ready?

data/lib/pdk/module/release.rb

@@ -0,0 +1,260 @@
+require 'pdk'
+
+module PDK
+  module Module
+    class Release
+      def self.invoke(module_path, options = {})
+        new(module_path, options).run
+      end
+
+      attr_reader :options
+
+      attr_reader :module_path
+
+      def initialize(module_path, options = {})
+        @options = options
+
+        # TODO: Currently the release process can ONLY be run if the working directory IS the module root. However, in the future
+        # this WILL change, so we have the API arguments for it, but only accept `nil` for the first parameter
+        raise PDK::CLI::ExitWithError, _('Running the release process outside of the working directory is not supported') unless module_path.nil?
+
+        if module_path.nil?
+          module_path = PDK::Util.module_root
+          raise PDK::CLI::ExitWithError, _('The module release process requires a valid module path') % { module_path: module_path } if module_path.nil?
+        end
+        raise PDK::CLI::ExitWithError, _('%{module_path} is not a valid module') % { module_path: module_path } unless PDK::Util.in_module_root?(module_path)
+        @module_path = module_path
+      end
+
+      def run
+        # Pre-release checks
+        unless force?
+          raise PDK::CLI::ExitWithError, _('The module is not PDK compatible') if requires_pdk_compatibility? && !pdk_compatible?
+          raise PDK::CLI::ExitWithError, _('The module is not Forge compatible') if requires_forge_compatibility? && !forge_compatible?
+        end
+
+        # Note that these checks are duplicated in the run_publish method, however it's a much better
+        # experience to fail early, than going through the whole process, only to error at the end knowing full well
+        # it'll fail anyway.
+        validate_publish_options!
+
+        run_validations(options) unless skip_validation?
+
+        PDK.logger.info _('Releasing %{module_name} - from version %{module_version}') % {
+          module_name:    module_metadata.data['name'],
+          module_version: module_metadata.data['version'],
+        }
+
+        PDK::Util::ChangelogGenerator.generate_changelog unless skip_changelog?
+
+        # Calculate the new module version
+        new_version = specified_version
+        if new_version.nil? && !skip_changelog?
+          new_version = PDK::Util::ChangelogGenerator.compute_next_version(module_metadata.data['version'])
+        end
+        new_version = module_metadata.data['version'] if new_version.nil?
+
+        if new_version != module_metadata.data['version']
+          PDK.logger.info _('Updating version to %{module_version}') % {
+            module_version: new_version,
+          }
+
+          # Set the new version in metadata file
+          module_metadata.data['version'] = new_version
+          write_module_metadata!
+
+          # Update the changelog with the correct version
+          PDK::Util::ChangelogGenerator.generate_changelog unless skip_changelog?
+        end
+
+        run_documentation(options) unless skip_documentation?
+
+        run_dependency_checker(options) unless skip_dependency?
+
+        if skip_build?
+          # Even if we're skipping the build, we still need the name of the tarball
+          # Use the specified package path if set
+          package_file = specified_package if package_file.nil?
+          # Use the default as a last resort
+          package_file = default_package_filename if package_file.nil?
+        else
+          package_file = run_build(options)
+        end
+
+        run_publish(options.dup, package_file) unless skip_publish?
+      end
+
+      def module_metadata
+        @module_metada ||= PDK::Module::Metadata.from_file(File.join(module_path, 'metadata.json'))
+      end
+
+      def write_module_metadata!
+        module_metadata.write!(File.join(module_path, 'metadata.json'))
+        clear_cached_data
+      end
+
+      def default_package_filename
+        return @default_tarball_filename unless @default_tarball_filename.nil?
+        builder = PDK::Module::Build.new(module_dir: module_path)
+        @default_tarball_filename = builder.package_file
+      end
+
+      def run_validations(opts)
+        # TODO: Surely I can use a pre-existing class for this?
+        PDK::CLI::Util.validate_puppet_version_opts(opts)
+
+        PDK::CLI::Util.module_version_check
+
+        report = PDK::Report.new
+        puppet_env = PDK::CLI::Util.puppet_from_opts_or_env(opts)
+        PDK::Util::PuppetVersion.fetch_puppet_dev if opts[:'puppet-dev']
+        PDK::Util::RubyVersion.use(puppet_env[:ruby_version])
+
+        opts = opts.merge(puppet_env[:gemset])
+
+        PDK::Util::Bundler.ensure_bundle!(puppet_env[:gemset])
+
+        validators = PDK::Validate.validators
+        validators.each do |validator|
+          validator_exit_code = validator.invoke(report, opts.dup)
+          raise PDK::CLI::ExitWithError, _('An error occured during validation') unless validator_exit_code.zero?
+        end
+      end
+
+      def run_documentation(_opts)
+        PDK.logger.info _('Updating documentation using puppet strings')
+        docs_command = PDK::CLI::Exec::InteractiveCommand.new(PDK::CLI::Exec.bundle_bin, 'exec', 'puppet', 'strings', 'generate', '--format', 'markdown', '--out', 'REFERENCE.md')
+        docs_command.context = :module
+        result = docs_command.execute!
+        raise PDK::CLI::ExitWithError, _('An error occured generating the module documentation: %{stdout}') % { stdout: result[:stdout] } unless result[:exit_code].zero?
+      end
+
+      def run_dependency_checker(_opts)
+        # run dependency-checker and output dependent modules list
+        PDK.logger.info _('Running dependency checks')
+
+        dep_command = PDK::CLI::Exec::Command.new('dependency-checker', 'metadata.json')
+        dep_command.context = :module
+        result = dep_command.execute!
+
+        raise PDK::CLI::ExitWithError, _('An error occured checking the module dependencies: %{stdout}') % { stdout: result[:stdout] } unless result[:exit_code].zero?
+      end
+
+      # @return [String] Path to the built tarball
+      def run_build(opts)
+        PDK::Module::Build.invoke(opts.dup)
+      end
+
+      def run_publish(_opts, tarball_path)
+        validate_publish_options!
+        raise PDK::CLI::ExitWithError, _('Module tarball %{tarball_path} does not exist') % { tarball_path: tarball_path } unless PDK::Util::Filesystem.file?(tarball_path)
+
+        # TODO: Replace this code when the upload functionality is added to the forge ruby gem
+        require 'base64'
+        file_data = Base64.encode64(PDK::Util::Filesystem.read_file(tarball_path, open_args: 'rb'))
+
+        PDK.logger.info _('Uploading tarball to puppet forge...')
+        uri = URI(forge_upload_url)
+        require 'net/http'
+        request = Net::HTTP::Post.new(uri.path)
+        request['Authorization'] = 'Bearer ' + forge_token
+        request['Content-Type'] = 'application/json'
+        data = { file: file_data }
+
+        request.body = data.to_json
+
+        require 'openssl'
+        use_ssl = uri.class == URI::HTTPS
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: use_ssl) do |http|
+          http.request(request)
+        end
+
+        raise PDK::CLI::ExitWithError, _('Error uploading to Puppet Forge: %{result}') % { result: response } unless response.is_a?(Net::HTTPSuccess)
+        PDK.logger.info _('Publish to Forge was successful')
+      end
+
+      def validate_publish_options!
+        return if skip_publish?
+        raise PDK::CLI::ExitWithError, _('Missing forge-upload-url option') unless forge_upload_url
+        raise PDK::CLI::ExitWithError, _('Missing forge-token option') unless forge_token
+      end
+
+      def force?
+        options[:force]
+      end
+
+      def skip_build?
+        options[:'skip-build']
+      end
+
+      def skip_changelog?
+        options[:'skip-changelog']
+      end
+
+      def skip_dependency?
+        options[:'skip-dependency']
+      end
+
+      def skip_documentation?
+        options[:'skip-documentation']
+      end
+
+      def skip_publish?
+        options[:'skip-publish']
+      end
+
+      def skip_validation?
+        options[:'skip-validation']
+      end
+
+      def specified_version
+        options[:version]
+      end
+
+      def specified_package
+        options[:file]
+      end
+
+      def forge_token
+        options[:'forge-token']
+      end
+
+      def forge_upload_url
+        options[:'forge-upload-url']
+      end
+
+      def requires_pdk_compatibility?
+        # Validation, Changelog and Dependency checks require the
+        # module to be PDK Compatible
+        !(skip_validation? && skip_changelog? && skip_dependency?)
+      end
+
+      def requires_forge_compatibility?
+        # Pushing to the for requires the metadata to be forge compatible
+        !skip_publish?
+      end
+
+      #:nocov:
+      # These are just convenience methods and are tested elsewhere
+      def forge_compatible?
+        module_metadata.forge_ready?
+      end
+
+      def pdk_compatible?
+        return @pdk_compatible unless @pdk_compatible.nil?
+
+        builder = PDK::Module::Build.new(module_dir: module_path)
+        @pdk_compatible = builder.module_pdk_compatible?
+      end
+      #:nocov:
+
+      private
+
+      def clear_cached_data
+        @module_metadata = nil
+        @pdk_compatible = nil
+        @default_tarball_filename = nil
+      end
+    end
+  end
+end