openvox 7.37.1 → 8.19.0

data/lib/puppet/module_tool/shared_behaviors.rb

@@ -1,18 +1,20 @@
-module Puppet::ModuleTool::Shared
+# frozen_string_literal: true
 
+module Puppet::ModuleTool::Shared
   include Puppet::ModuleTool::Errors
 
   def get_local_constraints
-    @local      = Hash.new { |h,k| h[k] = { } }
-    @conditions = Hash.new { |h,k| h[k] = [] }
-    @installed  = Hash.new { |h,k| h[k] = [] }
+    @local      = Hash.new { |h, k| h[k] = {} }
+    @conditions = Hash.new { |h, k| h[k] = [] }
+    @installed  = Hash.new { |h, k| h[k] = [] }
 
     @environment.modules_by_path.values.flatten.each do |mod|
       mod_name = (mod.forge_name || mod.name).tr('/', '-')
       @installed[mod_name] << mod
       d = @local["#{mod_name}@#{mod.version}"]
       (mod.dependencies || []).each do |hash|
-        name, conditions = hash['name'], hash['version_requirement']
+        name = hash['name']
+        conditions = hash['version_requirement']
         name = name.tr('/', '-')
         d[name] = conditions
         @conditions[name] << {
@@ -25,9 +27,9 @@ module Puppet::ModuleTool::Shared
   end
 
   def get_remote_constraints(forge)
-    @remote   = Hash.new { |h,k| h[k] = { } }
+    @remote   = Hash.new { |h, k| h[k] = {} }
     @urls     = {}
-    @versions = Hash.new { |h,k| h[k] = [] }
+    @versions = Hash.new { |h, k| h[k] = [] }
 
     Puppet.notice _("Downloading from %{uri} ...") % { uri: forge.uri }
     author, modname = Puppet::ModuleTool.username_and_modname_from(@module_name)
@@ -36,9 +38,13 @@ module Puppet::ModuleTool::Shared
       mod_name, releases = pair
       mod_name = mod_name.tr('/', '-')
       releases.each do |rel|
-        semver = SemanticPuppet::Version.parse(rel['version']) rescue SemanticPuppet::Version::MIN
+        semver = begin
+          SemanticPuppet::Version.parse(rel['version'])
+        rescue
+          SemanticPuppet::Version::MIN
+        end
         @versions[mod_name] << { :vstring => rel['version'], :semver => semver }
-        @versions[mod_name].sort! { |a, b| a[:semver] <=> b[:semver] }
+        @versions[mod_name].sort_by! { |a| a[:semver] }
         @urls["#{mod_name}@#{rel['version']}"] = rel['file']
         d = @remote["#{mod_name}@#{rel['version']}"]
         (rel['dependencies'] || []).each do |name, conditions|
@@ -53,33 +59,40 @@ module Puppet::ModuleTool::Shared
     if @conditions[mod].all? { |c| c[:queued] || c[:module] == :you }
       return :latest
     end
-    return :best
+
+    :best
   end
 
   def annotated_version(mod, versions)
     if versions.empty?
-      return implicit_version(mod)
+      implicit_version(mod)
     else
-      return "#{implicit_version(mod)}: #{versions.last}"
+      "#{implicit_version(mod)}: #{versions.last}"
     end
   end
 
-  def resolve_constraints(dependencies, source = [{:name => :you}], seen = {}, action = @action)
-    dependencies = dependencies.map do |mod, range|
+  def resolve_constraints(dependencies, source = [{ :name => :you }], seen = {}, action = @action)
+    dependencies = dependencies.filter_map do |mod, range|
       source.last[:dependency] = range
 
       @conditions[mod] << {
-        :module     => source.last[:name],
-        :version    => source.last[:version],
+        :module => source.last[:name],
+        :version => source.last[:version],
         :dependency => range,
-        :queued     => true
+        :queued => true
       }
 
       if forced?
-        range = Puppet::Module.parse_range(@version) rescue Puppet::Module.parse_range('>= 0.0.0')
+        range = begin
+          Puppet::Module.parse_range(@version)
+        rescue
+          Puppet::Module.parse_range('>= 0.0.0')
+        end
       else
         range = (@conditions[mod]).map do |r|
-          Puppet::Module.parse_range(r[:dependency]) rescue Puppet::Module.parse_range('>= 0.0.0')
+          Puppet::Module.parse_range(r[:dependency])
+        rescue
+          Puppet::Module.parse_range('>= 0.0.0')
         end.inject(&:&)
       end
 
@@ -87,17 +100,18 @@ module Puppet::ModuleTool::Shared
         next if range === seen[mod][:semver]
 
         req_module   = @module_name
-        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        req_versions = @versions[@module_name.to_s].map { |v| v[:semver] }
         raise InvalidDependencyCycleError,
-          :module_name       => mod,
-          :source            => (source + [{ :name => mod, :version => source.last[:dependency] }]),
-          :requested_module  => req_module,
-          :requested_version => @version || annotated_version(req_module, req_versions),
-          :conditions        => @conditions
+              :module_name => mod,
+              :source => (source + [{ :name => mod, :version => source.last[:dependency] }]),
+              :requested_module => req_module,
+              :requested_version => @version || annotated_version(req_module, req_versions),
+              :conditions => @conditions
       end
 
       if !(forced? || @installed[mod].empty? || source.last[:name] == :you)
         next if range === SemanticPuppet::Version.parse(@installed[mod].first.version)
+
         action = :upgrade
       elsif @installed[mod].empty?
         action = :install
@@ -107,40 +121,44 @@ module Puppet::ModuleTool::Shared
         @conditions.each { |_, conds| conds.delete_if { |c| c[:module] == mod } }
       end
 
-      versions = @versions["#{mod}"].select { |h| range === h[:semver] }
+      versions = @versions[mod.to_s].select { |h| range === h[:semver] }
       valid_versions = versions.select { |x| x[:semver].special == '' }
       valid_versions = versions if valid_versions.empty?
 
       version = valid_versions.last
       unless version
         req_module   = @module_name
-        req_versions = @versions["#{@module_name}"].map { |v| v[:semver] }
+        req_versions = @versions[@module_name.to_s].map { |v| v[:semver] }
         raise NoVersionsSatisfyError,
-          :requested_name    => req_module,
-          :requested_version => @version || annotated_version(req_module, req_versions),
-          :installed_version => @installed[@module_name].empty? ? nil : @installed[@module_name].first.version,
-          :dependency_name   => mod,
-          :conditions        => @conditions[mod],
-          :action            => @action
+              :requested_name => req_module,
+              :requested_version => @version || annotated_version(req_module, req_versions),
+              :installed_version => @installed[@module_name].empty? ? nil : @installed[@module_name].first.version,
+              :dependency_name => mod,
+              :conditions => @conditions[mod],
+              :action => @action
       end
 
       seen[mod] = version
 
       {
-        :module           => mod,
-        :version          => version,
-        :action           => action,
+        :module => mod,
+        :version => version,
+        :action => action,
         :previous_version => @installed[mod].empty? ? nil : @installed[mod].first.version,
-        :file             => @urls["#{mod}@#{version[:vstring]}"],
-        :path             => action == :install ? @options[:target_dir] : (@installed[mod].empty? ? @options[:target_dir] : @installed[mod].first.modulepath),
-        :dependencies     => []
+        :file => @urls["#{mod}@#{version[:vstring]}"],
+        :path => if action == :install
+                   @options[:target_dir]
+                 else
+                   @installed[mod].empty? ? @options[:target_dir] : @installed[mod].first.modulepath
+                 end,
+        :dependencies => []
       }
-    end.compact
+    end
     dependencies.each do |mod|
       deps = @remote["#{mod[:module]}@#{mod[:version][:vstring]}"].sort_by(&:first)
       mod[:dependencies] = resolve_constraints(deps, source + [{ :name => mod[:module], :version => mod[:version][:vstring] }], seen, :install)
     end unless @ignore_dependencies
-    return dependencies
+    dependencies
   end
 
   def download_tarballs(graph, default_path, forge)
@@ -156,7 +174,7 @@ module Puppet::ModuleTool::Shared
       end
 
       [
-        { (release[:path] ||= default_path) => cache_path},
+        { (release[:path] ||= default_path) => cache_path },
         *download_tarballs(release[:dependencies], default_path, forge)
       ]
     end.flatten
@@ -172,7 +190,7 @@ module Puppet::ModuleTool::Shared
     # problems at install time, we should reject any solution that
     # depends on multiple nodes with the same "module name".
     graph.add_graph_constraint('PMT') do |nodes|
-      names = nodes.map { |x| x.dependency_names + [ x.name ] }.flatten
+      names = nodes.map { |x| x.dependency_names + [x.name] }.flatten
       names = names.map { |x| x.tr('/', '-') }.uniq
       names = names.map { |x| x[/-(.*)/, 1] }
       names.length == names.uniq.length

data/lib/puppet/module_tool/tar/gnu.rb

@@ -1,19 +1,23 @@
+# frozen_string_literal: true
+
 require 'shellwords'
 
 class Puppet::ModuleTool::Tar::Gnu
   def unpack(sourcefile, destdir, owner)
-    sourcefile = File.expand_path(sourcefile)
+    safe_sourcefile = Shellwords.shellescape(File.expand_path(sourcefile))
     destdir = File.expand_path(destdir)
+    safe_destdir = Shellwords.shellescape(destdir)
 
-    Dir.chdir(destdir) do
-      Puppet::Util::Execution.execute("gzip -dc #{Shellwords.shellescape(sourcefile)} | tar xof -")
-      Puppet::Util::Execution.execute("find . -type d -exec chmod 755 {} +")
-      Puppet::Util::Execution.execute("find . -type f -exec chmod u+rw,g+r,a-st {} +")
-      Puppet::Util::Execution.execute("chown -R #{owner} .")
-    end
+    Puppet::Util::Execution.execute("gzip -dc #{safe_sourcefile} | tar --extract --no-same-owner --directory #{safe_destdir} --file -")
+    Puppet::Util::Execution.execute(['find', destdir, '-type', 'd', '-exec', 'chmod', '755', '{}', '+'])
+    Puppet::Util::Execution.execute(['find', destdir, '-type', 'f', '-exec', 'chmod', 'u+rw,g+r,a-st', '{}', '+'])
+    Puppet::Util::Execution.execute(['chown', '-R', owner, destdir])
   end
 
   def pack(sourcedir, destfile)
-    Puppet::Util::Execution.execute("tar cf - #{sourcedir} | gzip -c > #{File.basename(destfile)}")
+    safe_sourcedir = Shellwords.shellescape(sourcedir)
+    safe_destfile = Shellwords.shellescape(File.basename(destfile))
+
+    Puppet::Util::Execution.execute("tar cf - #{safe_sourcedir} | gzip -c > #{safe_destfile}")
   end
 end

data/lib/puppet/module_tool/tar/mini.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Puppet::ModuleTool::Tar::Mini
   def unpack(sourcefile, destdir, _)
     Zlib::GzipReader.open(sourcefile) do |reader|
@@ -9,7 +11,7 @@ class Puppet::ModuleTool::Tar::Mini
       args = [reader, destdir, find_valid_files(reader)]
       spec = Gem::Specification.find_by_name('minitar')
       if spec && spec.version >= Gem::Version.new('0.9')
-        args << {:fsync => false}
+        args << { :fsync => false }
       end
       Archive::Tar::Minitar.unpack(*args) do |action, name, stats|
         case action
@@ -42,9 +44,9 @@ class Puppet::ModuleTool::Tar::Mini
 
   private
 
-  EXECUTABLE = 0755
-  NOT_EXECUTABLE = 0644
-  USER_EXECUTE = 0100
+  EXECUTABLE = 0o755
+  NOT_EXECUTABLE = 0o644
+  USER_EXECUTE = 0o100
 
   def set_dir_mode!(stats)
     if stats.key?(:mode)

data/lib/puppet/module_tool/tar.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/module_tool'
 require_relative '../../puppet/util'
 
@@ -8,10 +10,10 @@ module Puppet::ModuleTool::Tar
   def self.instance
     if Puppet.features.minitar? && Puppet.features.zlib?
       Mini.new
-    elsif Puppet::Util.which('tar') && ! Puppet::Util::Platform.windows?
+    elsif Puppet::Util.which('tar') && !Puppet::Util::Platform.windows?
       Gnu.new
     else
-      #TRANSLATORS "tar" is a program name and should not be translated
+      # TRANSLATORS "tar" is a program name and should not be translated
       raise RuntimeError, _('No suitable tar implementation found')
     end
   end

data/lib/puppet/module_tool.rb

@@ -1,4 +1,6 @@
 # encoding: UTF-8
+# frozen_string_literal: true
+
 # Load standard libraries
 require 'pathname'
 require 'fileutils'
@@ -11,7 +13,7 @@ module Puppet
 
     # Directory and names that should not be checksummed.
     ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'checksums.json', 'REVISION']
-    FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
+    FULL_MODULE_NAME_PATTERN = %r{\A([^-/|.]+)[-|/](.+)\z}
     REPOSITORY_URL = Puppet.settings[:module_repository]
 
     # Is this a directory that shouldn't be checksummed?
@@ -33,7 +35,7 @@ module Puppet
     def self.username_and_modname_from(full_module_name)
       matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
       if matcher
-        return matcher.captures
+        matcher.captures
       else
         raise ArgumentError, _("Not a valid full name: %{full_module_name}") % { full_module_name: full_module_name }
       end
@@ -46,7 +48,7 @@ module Puppet
     # @return [Pathname, nil] the root path of the module directory or nil if
     #   we cannot find one
     def self.find_module_root(path)
-      path = Pathname.new(path) if path.class == String
+      path = Pathname.new(path) if path.instance_of?(String)
 
       path.expand_path.ascend do |p|
         return p if is_module_root?(p)
@@ -61,7 +63,7 @@ module Puppet
     # @param path [Pathname, String] path to analyse
     # @return [Boolean] true if the path is a module root, false otherwise
     def self.is_module_root?(path)
-      path = Pathname.new(path) if path.class == String
+      path = Pathname.new(path) if path.instance_of?(String)
 
       FileTest.file?(path + 'metadata.json')
     end
@@ -69,7 +71,7 @@ module Puppet
     # Builds a formatted tree from a list of node hashes containing +:text+
     # and +:dependencies+ keys.
     def self.format_tree(nodes, level = 0)
-      str = ''
+      str = ''.dup
       nodes.each_with_index do |node, i|
         last_node = nodes.length - 1 == i
         deps = node[:dependencies] || []
@@ -85,7 +87,7 @@ module Puppet
         str << branch
       end
 
-      return str
+      str
     end
 
     def self.build_tree(mods, dir)
@@ -100,8 +102,8 @@ module Puppet
         mod[:text] = "#{mod[:name]} (#{colorize(:cyan, version_string)})"
         mod[:text] += " [#{mod[:path]}]" unless mod[:path].to_s == dir.to_s
 
-        deps = (mod[:dependencies] || [])
-        deps.sort! { |a, b| a[:name] <=> b[:name] }
+        deps = mod[:dependencies] || []
+        deps.sort_by! { |a| a[:name] }
         build_tree(deps, dir)
       end
     end
@@ -131,7 +133,6 @@ module Puppet
 
       # Note: environment will have expanded the path
       options[:target_dir] = face_environment.full_modulepath.first
-
     end
 
     # Given a hash of options, we should discover or create a
@@ -178,7 +179,7 @@ module Puppet
         parsed_range = SemanticPuppet::VersionRange::EMPTY_RANGE
       end
 
-      [ dep_name, parsed_range, range ]
+      [dep_name, parsed_range, range]
     end
   end
 end
@@ -187,7 +188,6 @@ end
 require_relative 'module_tool/errors'
 require_relative 'module_tool/applications'
 require_relative 'module_tool/checksums'
-require_relative 'module_tool/contents_description'
 require_relative 'module_tool/dependency'
 require_relative 'module_tool/metadata'
 require_relative '../puppet/forge/cache'

data/lib/puppet/network/authconfig.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet
   class Network::AuthConfig
     def self.authprovider_class=(_)

data/lib/puppet/network/authorization.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Network
   module Authorization
     class << self

data/lib/puppet/network/client_request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Network # :nodoc:
   # A struct-like class for passing around a client request.  It's mostly
   # just used for validation and authorization.
@@ -5,7 +7,7 @@ module Puppet::Network # :nodoc:
     attr_accessor :name, :ip, :authenticated, :handler, :method
 
     def authenticated?
-      self.authenticated
+      authenticated
     end
 
     # A common way of talking about the full call.  Individual servers
@@ -18,12 +20,13 @@ module Puppet::Network # :nodoc:
     end
 
     def initialize(name, ip, authenticated)
-      @name, @ip, @authenticated = name, ip, authenticated
+      @name = name
+      @ip = ip
+      @authenticated = authenticated
     end
 
     def to_s
-      "#{self.name}(#{self.ip})"
+      "#{name}(#{ip})"
     end
   end
 end
-

data/lib/puppet/network/format.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/confiner'
 
 # A simple class for modeling encoding formats for moving
@@ -12,7 +14,7 @@ class Puppet::Network::Format
     value = @options.delete(name)
     value = default if value.nil?
 
-    self.send(name.to_s + "=", value)
+    send(name.to_s + "=", value)
   end
 
   def initialize(name, options = {}, &block)
@@ -49,11 +51,13 @@ class Puppet::Network::Format
 
   def intern(klass, text)
     return klass.send(intern_method, text) if klass.respond_to?(intern_method)
+
     raise NotImplementedError, "#{klass} does not respond to #{intern_method}; can not intern instances from #{mime}"
   end
 
   def intern_multiple(klass, text)
     return klass.send(intern_multiple_method, text) if klass.respond_to?(intern_multiple_method)
+
     raise NotImplementedError, "#{klass} does not respond to #{intern_multiple_method}; can not intern multiple instances from #{mime}"
   end
 
@@ -63,14 +67,16 @@ class Puppet::Network::Format
 
   def render(instance)
     return instance.send(render_method) if instance.respond_to?(render_method)
+
     raise NotImplementedError, "#{instance.class} does not respond to #{render_method}; can not render instances to #{mime}"
   end
 
   def render_multiple(instances)
     # This method implicitly assumes that all instances are of the same type.
     return instances[0].class.send(render_multiple_method, instances) if instances[0].class.respond_to?(render_multiple_method)
+
     raise NotImplementedError, _("%{klass} does not respond to %{method}; can not render multiple instances to %{mime}") %
-        { klass: instances[0].class, method: render_multiple_method, mime: mime }
+                               { klass: instances[0].class, method: render_multiple_method, mime: mime }
   end
 
   def required_methods_present?(klass)
@@ -105,6 +111,6 @@ class Puppet::Network::Format
 
     method = send(name)
 
-    return(type == :class ? klass.respond_to?(method) : klass.method_defined?(method))
+    (type == :class ? klass.respond_to?(method) : klass.method_defined?(method))
   end
 end

data/lib/puppet/network/format_handler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 require_relative '../../puppet/network'
 require_relative '../../puppet/network/format'
@@ -5,7 +7,7 @@ require_relative '../../puppet/network/format'
 module Puppet::Network::FormatHandler
   class FormatError < Puppet::Error; end
 
-  ALL_MEDIA_TYPES = '*/*'.freeze
+  ALL_MEDIA_TYPES = '*/*'
 
   @formats = {}
 
@@ -16,9 +18,9 @@ module Puppet::Network::FormatHandler
     instance
   end
 
-  def self.create_serialized_formats(name,options = {},&block)
+  def self.create_serialized_formats(name, options = {}, &block)
     ["application/x-#{name}", "application/#{name}", "text/x-#{name}", "text/#{name}"].each { |mime_type|
-      create name, {:mime => mime_type}.update(options), &block
+      create name, { :mime => mime_type }.update(options), &block
     }
   end
 
@@ -32,7 +34,7 @@ module Puppet::Network::FormatHandler
   end
 
   def self.format_by_extension(ext)
-    @formats.each do |name, format|
+    @formats.each do |_name, format|
       return format if format.extension == ext
     end
     nil
@@ -64,7 +66,7 @@ module Puppet::Network::FormatHandler
     end
 
     if out.nil?
-      raise ArgumentError, _("No format matches the given format name or mime-type (%{format})") % {format: format}
+      raise ArgumentError, _("No format matches the given format name or mime-type (%{format})") % { format: format }
     end
 
     out.name
@@ -84,13 +86,13 @@ module Puppet::Network::FormatHandler
   def self.most_suitable_formats_for(accepted, supported)
     accepted.collect do |format|
       format.to_s.sub(/;q=.*$/, '')
-    end.collect do |format|
+    end.filter_map do |format|
       if format == ALL_MEDIA_TYPES
         supported.first
       else
         format_to_canonical_name_or_nil(format)
       end
-    end.compact.find_all do |format|
+    end.find_all do |format|
       supported.include?(format)
     end.collect do |format|
       format_for(format)

data/lib/puppet/network/format_support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/network/format_handler'
 
 # Provides network serialization support when included
@@ -11,21 +13,21 @@ module Puppet::Network::FormatSupport
     def convert_from(format, data)
       get_format(format).intern(self, data)
     rescue => err
-      #TRANSLATORS "intern" is a function name and should not be translated
+      # TRANSLATORS "intern" is a function name and should not be translated
       raise Puppet::Network::FormatHandler::FormatError, _("Could not intern from %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def convert_from_multiple(format, data)
       get_format(format).intern_multiple(self, data)
     rescue => err
-      #TRANSLATORS "intern_multiple" is a function name and should not be translated
+      # TRANSLATORS "intern_multiple" is a function name and should not be translated
       raise Puppet::Network::FormatHandler::FormatError, _("Could not intern_multiple from %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
     def render_multiple(format, instances)
       get_format(format).render_multiple(instances)
     rescue => err
-      #TRANSLATORS "render_multiple" is a function name and should not be translated
+      # TRANSLATORS "render_multiple" is a function name and should not be translated
       raise Puppet::Network::FormatHandler::FormatError, _("Could not render_multiple to %{format}: %{err}") % { format: format, err: err }, err.backtrace
     end
 
@@ -66,7 +68,7 @@ module Puppet::Network::FormatSupport
     end
 
     def friendly_name
-      if self.respond_to? :indirection
+      if respond_to? :indirection
         indirection.name
       else
         self
@@ -110,7 +112,7 @@ module Puppet::Network::FormatSupport
 
     self.class.get_format(format).render(self)
   rescue => err
-    #TRANSLATORS "render" is a function name and should not be translated
+    # TRANSLATORS "render" is a function name and should not be translated
     raise Puppet::Network::FormatHandler::FormatError, _("Could not render to %{format}: %{err}") % { format: format, err: err }, err.backtrace
   end
 
@@ -119,7 +121,7 @@ module Puppet::Network::FormatSupport
 
     self.class.get_format(format).mime
   rescue => err
-    #TRANSLATORS "mime" is a function name and should not be translated
+    # TRANSLATORS "mime" is a function name and should not be translated
     raise Puppet::Network::FormatHandler::FormatError, _("Could not mime to %{format}: %{err}") % { format: format, err: err }, err.backtrace
   end
 
@@ -136,4 +138,3 @@ module Puppet::Network::FormatSupport
   # If the method exists it will be called from to_msgpack and other serialization methods.
   # @return [Hash]
 end
-