build.rb in pdk-3.0.0

- old
+ new

@@ -5,12 +5,11 @@
     class Build
       def self.invoke(options = {})
         new(options).build
       end
 
-      attr_reader :module_dir
-      attr_reader :target_dir
+      attr_reader :module_dir, :target_dir
 
       def initialize(options = {})
         @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
@@ -84,11 +83,11 @@
       #
       # @return [String] The module name and version, joined by a dash.
       def release_name
         @release_name ||= [
           metadata['name'],
-          metadata['version'],
+          metadata['version']
         ].join('-')
       end
 
       # Iterate through all the files and directories in the module and stage
       # them into the temporary build directory (unless ignored).
@@ -124,22 +123,22 @@
         else
           validate_ustar_path!(relative_path.to_path)
           PDK::Util::Filesystem.cp(path, dest_path, preserve: true)
         end
       rescue ArgumentError => e
-        raise PDK::CLI::ExitWithError, '%{message} Rename the file or exclude it from the package ' \
-                                       'by adding it to the .pdkignore file in your module.' % { message: e.message }
+        raise PDK::CLI::ExitWithError, format('%{message} Rename the file or exclude it from the package ' \
+                                              'by adding it to the .pdkignore file in your module.', message: e.message)
       end
 
       # Check if the given path matches one of the patterns listed in the
       # ignore file.
       #
       # @param path [String] The path to be checked.
       #
       # @return [Boolean] true if the path matches and should be ignored.
       def ignored_path?(path)
-        path = path.to_s + '/' if PDK::Util::Filesystem.directory?(path)
+        path = "#{path}/" if PDK::Util::Filesystem.directory?(path)
 
         !ignored_files.match_paths([path], module_dir).empty?
       end
 
       # Warn the user about a symlink that would have been included in the
@@ -152,14 +151,12 @@
         require 'pathname'
 
         symlink_path = Pathname.new(path)
         module_path = Pathname.new(module_dir)
 
-        PDK.logger.warn 'Symlinks in modules are not supported and will not be included in the package. Please investigate symlink %{from} -> %{to}.' % {
-          from: symlink_path.relative_path_from(module_path),
-          to:   symlink_path.realpath.relative_path_from(module_path),
-        }
+        PDK.logger.warn format('Symlinks in modules are not supported and will not be included in the package. Please investigate symlink %{from} -> %{to}.',
+                               from: symlink_path.relative_path_from(module_path), to: symlink_path.realpath.relative_path_from(module_path))
       end
 
       # Checks if the path length will fit into the POSIX.1-1998 (ustar) tar
       # header format.
       #
@@ -178,15 +175,11 @@
       #
       # @raise [ArgumentError] if the path is too long or could not be split.
       #
       # @return [nil]
       def validate_ustar_path!(path)
-        if path.bytesize > 256
-          raise ArgumentError, "The path '%{path}' is longer than 256 bytes." % {
-            path: path,
-          }
-        end
+        raise ArgumentError, format("The path '%{path}' is longer than 256 bytes.", path: path) if path.bytesize > 256
 
         if path.bytesize <= 100
           prefix = ''
         else
           parts = path.split(File::SEPARATOR)
@@ -194,23 +187,24 @@
           nxt = ''
 
           loop do
             nxt = parts.pop || ''
             break if newpath.bytesize + 1 + nxt.bytesize >= 100
+
             newpath = File.join(nxt, newpath)
           end
 
           prefix = File.join(*parts, nxt)
           path = newpath
         end
 
         return unless path.bytesize > 100 || prefix.bytesize > 155
 
         raise ArgumentError,
-              "'%{path}' could not be split at a directory separator into two " \
-              'parts, the first having a maximum length of 155 bytes and the ' \
-              'second having a maximum length of 100 bytes.' % { path: path }
+              format("'%{path}' could not be split at a directory separator into two " \
+                     'parts, the first having a maximum length of 155 bytes and the ' \
+                     'second having a maximum length of 100 bytes.', path: path)
       end
 
       # Checks if the path contains any non-ASCII characters.
       #
       # Java will throw an error when it encounters a path containing
@@ -222,14 +216,14 @@
       #
       # @raise [ArgumentError] if the path contains non-ASCII characters.
       #
       # @return [nil]
       def validate_path_encoding!(path)
-        return unless path =~ %r{[^\x00-\x7F]}
+        return unless /[^\x00-\x7F]/.match?(path)
 
-        raise ArgumentError, "'%{path}' can only include ASCII characters in its path or " \
-                             'filename in order to be compatible with a wide range of hosts.' % { path: path }
+        raise ArgumentError, format("'%{path}' can only include ASCII characters in its path or " \
+                                    'filename in order to be compatible with a wide range of hosts.', path: path)
       end
 
       # Creates a gzip compressed tarball of the build directory.
       #
       # If the destination package already exists, it will be removed before
@@ -242,35 +236,28 @@
         require 'find'
 
         PDK::Util::Filesystem.rm_f(package_file)
 
         Dir.chdir(target_dir) do
-          begin
-            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,
-              }
+          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 = PDK::Util::Filesystem.stat(entry).mode
-              min_mode = Minitar.dir?(entry) ? 0o755 : 0o644
+            orig_mode = PDK::Util::Filesystem.stat(entry).mode
+            min_mode = Minitar.dir?(entry) ? 0o755 : 0o644
 
-              entry_meta[:mode] = orig_mode | min_mode
+            entry_meta[:mode] = orig_mode | min_mode
 
-              if entry_meta[:mode] != orig_mode
-                PDK.logger.debug('Updated permissions of packaged \'%{entry}\' to %{new_mode}' % {
-                  entry: entry,
-                  new_mode: (entry_meta[:mode] & 0o7777).to_s(8),
-                })
-              end
+            PDK.logger.debug(format('Updated permissions of packaged \'%{entry}\' to %{new_mode}', entry: entry, new_mode: (entry_meta[:mode] & 0o7777).to_s(8))) if entry_meta[:mode] != orig_mode
 
-              Minitar.pack_file(entry_meta, tar)
-            end
-          ensure
-            tar.close
+            Minitar.pack_file(entry_meta, tar)
           end
+        ensure
+          tar.close
         end
       end
 
       # Select the most appropriate ignore file in the module directory.
       #
@@ -281,11 +268,11 @@
       #   paths to ignore.
       def ignore_file
         @ignore_file ||= [
           File.join(module_dir, '.pdkignore'),
           File.join(module_dir, '.pmtignore'),
-          File.join(module_dir, '.gitignore'),
+          File.join(module_dir, '.gitignore')
         ].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
       # files to be ignored.
@@ -301,12 +288,10 @@
                         PathSpec.new
                       else
                         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))
-              ignored = ignored.add("\/#{File.basename(target_dir)}\/")
-            end
+            ignored = ignored.add("/#{File.basename(target_dir)}/") if File.realdirpath(target_dir).start_with?(File.realdirpath(module_dir))
 
             PDK::Module::DEFAULT_IGNORED.each { |r| ignored.add(r) }
 
             ignored
           end