openvox 7.37.1 → 8.19.0

data/lib/puppet/functions/tree_each.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Runs a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 # recursively and repeatedly using values from a data structure, then returns the unchanged data structure, or if
 # a lambda is not given, returns an `Iterator` for the tree.
@@ -140,7 +142,6 @@
 # @since 5.0.0
 #
 Puppet::Functions.create_function(:tree_each) do
-
   local_types do
     type "OptionsType  = Struct[{\
       container_type => Optional[Type],\
@@ -170,12 +171,12 @@ Puppet::Functions.create_function(:tree_each) do
   end
 
   def tree_Enumerable1(enum, options = {}, &block)
-    iterator(enum, options).each {|_, v| yield(v) }
+    iterator(enum, options).each { |_, v| yield(v) }
     enum
   end
 
   def tree_Enumerable2(enum, options = {}, &block)
-    iterator(enum, options).each {|path, v| yield(path, v) }
+    iterator(enum, options).each { |path, v| yield(path, v) }
     enum
   end
 

data/lib/puppet/functions/type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Returns the data type of a given value with a given degree of generality.
 #
 # ```puppet

data/lib/puppet/functions/unique.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Produces a unique set of values from an `Iterable` argument.
 #
 # * If the argument is a `String`, the unique set of characters are returned as a new `String`.
@@ -56,15 +58,16 @@
 # ['aBc', 'AbC', 'bbb'].unique |$x| { String($x,'%d') }
 #
 # # will produce {[a] => [10], [b, c, d, e] => [11, 12, 100]}
-# {a => 10, b => 11, c => 12, d => 100, e => 11}.unique |$v| { if $v > 10 { big } else { $v } } 
+# {a => 10, b => 11, c => 12, d => 100, e => 11}.unique |$v| { if $v > 10 { big } else { $v } }
 # ```
 #
 # Note that for `Hash` the result is slightly different than for the other data types. For those the result contains the
 # *first-found* unique value, but for `Hash` it contains associations from a set of keys to the set of values clustered by the
 # equality lambda (or the default value equality if no lambda was given). This makes the `unique` function more versatile for hashes
 # in general, while requiring that the simple computation of "hash's unique set of values" is performed as `$hsh.map |$k, $v| { $v }.unique`.
-# (A unique set of hash keys is in general meaningless (since they are unique by definition) - although if processed with a different
-# lambda for equality that would be different. First map the hash to an array of its keys if such a unique computation is wanted). 
+# (Generally, it's meaningless to compute the unique set of hash keys because they are unique by definition. However, the
+# situation can change if the hash keys are processed with a different lambda for equality. For this unique computation,
+# first map the hash to an array of its keys.)
 # If the more advanced clustering is wanted for one of the other data types, simply transform it into a `Hash` as shown in the
 # following example.
 #
@@ -109,20 +112,20 @@ Puppet::Functions.create_function(:unique) do
   end
 
   def unique_hash(hash, &block)
-    block = lambda {|v| v } unless block_given?
-    result = Hash.new {|h, k| h[k] = {:keys =>[], :values =>[]} }
-    hash.each_pair do |k,v|
-      rc = result[ block.call(v) ]
+    block = ->(v) { v } unless block_given?
+    result = Hash.new { |h, k| h[k] = { :keys => [], :values => [] } }
+    hash.each_pair do |k, v|
+      rc = result[block.call(v)]
       rc[:keys] << k
       rc[:values] << v
     end
     # reduce the set of possibly duplicated value entries
     inverted = {}
-    result.each_pair {|k,v| inverted[v[:keys]] = v[:values].uniq }
+    result.each_pair { |_k, v| inverted[v[:keys]] = v[:values].uniq }
     inverted
   end
 
-  def unique_array(array,&block)
+  def unique_array(array, &block)
     array.uniq(&block)
   end
 

data/lib/puppet/functions/unwrap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Unwraps a Sensitive value and returns the wrapped object.
 # Returns the Value itself, if it is not Sensitive.
 #

data/lib/puppet/functions/upcase.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Converts a String, Array or Hash (recursively) into upper case.
 #
 # This function is compatible with the stdlib function with the same name.
@@ -74,12 +76,12 @@ Puppet::Functions.create_function(:upcase) do
   end
 
   def on_array(a)
-    a.map {|x| do_upcase(x) }
+    a.map { |x| do_upcase(x) }
   end
 
   def on_hash(h)
     result = {}
-    h.each_pair {|k,v| result[do_upcase(k)] = do_upcase(v) }
+    h.each_pair { |k, v| result[do_upcase(k)] = do_upcase(v) }
     result
   end
 

data/lib/puppet/functions/values.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Returns the values of a hash as an Array
 #
 # @example Using `values`

data/lib/puppet/functions/versioncmp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/util/package'
 
 # Compares two version numbers.
@@ -27,7 +29,6 @@ require_relative '../../puppet/util/package'
 # `package` type.
 #
 Puppet::Functions.create_function(:versioncmp) do
-
   dispatch :versioncmp do
     param 'String', :a
     param 'String', :b

data/lib/puppet/functions/warning.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Logs a message on the server at level `warning`.
 Puppet::Functions.create_function(:warning, Puppet::Functions::InternalFunction) do
   # @param values The values to log.

data/lib/puppet/functions/with.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Calls a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
 # with the given arguments and returns the result.
 #

data/lib/puppet/functions/yaml_data.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require 'yaml'
 
@@ -22,20 +23,19 @@ Puppet::Functions.create_function(:yaml_data) do
   def yaml_data(options, context)
     path = options['path']
     context.cached_file_data(path) do |content|
-      begin
-        data = Puppet::Util::Yaml.safe_load(content, [Symbol], path)
-        if data.is_a?(Hash)
-          Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
-        else
-          msg = _("%{path}: file does not contain a valid yaml hash" % { path: path })
-          raise Puppet::DataBinding::LookupError, msg if Puppet[:strict] == :error && data != false
-          Puppet.warning(msg)
-          {}
-        end
-      rescue Puppet::Util::Yaml::YamlLoadError => ex
-        # YamlLoadErrors include the absolute path to the file, so no need to add that
-        raise Puppet::DataBinding::LookupError, _("Unable to parse %{message}") % { message: ex.message }
+      data = Puppet::Util::Yaml.safe_load(content, [Symbol], path)
+      if data.is_a?(Hash)
+        Puppet::Pops::Lookup::HieraConfig.symkeys_to_string(data)
+      else
+        msg = _("%{path}: file does not contain a valid yaml hash" % { path: path })
+        raise Puppet::DataBinding::LookupError, msg if Puppet[:strict] == :error && data != false
+
+        Puppet.warning(msg)
+        {}
       end
+    rescue Puppet::Util::Yaml::YamlLoadError => ex
+      # YamlLoadErrors include the absolute path to the file, so no need to add that
+      raise Puppet::DataBinding::LookupError, _("Unable to parse %{message}") % { message: ex.message }
     end
   end
 

data/lib/puppet/functions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Functions in the puppet language can be written in Ruby and distributed in
 # puppet modules. The function is written by creating a file in the module's
 # `lib/puppet/functions/<modulename>` directory, where `<modulename>` is
@@ -186,12 +188,11 @@ module Puppet::Functions
     # and it will fail unless protected with an if defined? if the local
     # variable does not exist in the block's binder.
     #
-    begin
-      loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
-      create_loaded_function(func_name, loader, function_base, &block)
-    rescue StandardError => e
-      raise ArgumentError, _("Function Load Error for function '%{function_name}': %{message}") % {function_name: func_name, message: e.message}
-    end
+
+    loader = block.binding.eval('loader_injected_arg if defined?(loader_injected_arg)')
+    create_loaded_function(func_name, loader, function_base, &block)
+  rescue StandardError => e
+    raise ArgumentError, _("Function Load Error for function '%{function_name}': %{message}") % { function_name: func_name, message: e.message }
   end
 
   # Creates a function in, or in a local loader under the given loader.
@@ -271,14 +272,15 @@ module Puppet::Functions
     unless the_class.method_defined?(func_name)
       raise ArgumentError, _("Function Creation Error, cannot create a default dispatcher for function '%{func_name}', no method with this name found") % { func_name: func_name }
     end
+
     any_signature(*min_max_param(the_class.instance_method(func_name)))
   end
 
   # @api private
   def self.min_max_param(method)
-    result = {:req => 0, :opt => 0, :rest => 0 }
+    result = { :req => 0, :opt => 0, :rest => 0 }
     # count per parameter kind, and get array of names
-    names = method.parameters.map { |p| result[p[0]] += 1 ; p[1].to_s }
+    names = method.parameters.map { |p| result[p[0]] += 1; p[1].to_s }
     from = result[:req]
     to = result[:rest] > 0 ? :default : from + result[:opt]
     [from, to, names]
@@ -302,7 +304,6 @@ module Puppet::Functions
   #
   # @api public
   class Function < Puppet::Pops::Functions::Function
-
     # @api private
     def self.builder
       DispatcherBuilder.new(dispatcher, Puppet::Pops::Types::PCallableType::DEFAULT, loader)
@@ -349,6 +350,7 @@ module Puppet::Functions
       if loader.nil?
         raise ArgumentError, _("No loader present. Call create_loaded_function(:myname, loader,...), instead of 'create_function' if running tests")
       end
+
       aliases = LocalTypeAliasesBuilder.new(loader, name)
       aliases.instance_eval(&block)
       # Add the loaded types to the builder
@@ -385,7 +387,6 @@ module Puppet::Functions
     end
   end
 
-
   # Public api methods of the DispatcherBuilder are available within dispatch()
   # blocks declared in a Puppet::Function.create_function() call.
   #
@@ -412,6 +413,7 @@ module Puppet::Functions
     def param(type, name)
       internal_param(type, name)
       raise ArgumentError, _('A required parameter cannot be added after an optional parameter') if @min != @max
+
       @min += 1
       @max += 1
     end
@@ -461,6 +463,7 @@ module Puppet::Functions
     def required_repeated_param(type, name)
       internal_param(type, name, true)
       raise ArgumentError, _('A required repeated parameter cannot be added after an optional parameter') if @min != @max
+
       @min += 1
       @max = :default
     end
@@ -521,6 +524,7 @@ module Puppet::Functions
       unless type.is_a?(String) || type.is_a?(Puppet::Pops::Types::PAnyType)
         raise ArgumentError, _("Argument to 'return_type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class }
       end
+
       @return_type = type
     end
 
@@ -542,7 +546,7 @@ module Puppet::Functions
         if repeat
           @weaving << -@names.size()
         else
-          @weaving << @names.size()-1
+          @weaving << @names.size() - 1
         end
       else
         raise ArgumentError, _("Parameter 'type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class }
@@ -565,7 +569,7 @@ module Puppet::Functions
       @block_name = nil
       @return_type = nil
       @argument_mismatch_hander = argument_mismatch_handler
-      self.instance_eval(&block)
+      instance_eval(&block)
       callable_t = create_callable(@types, @block_type, @return_type, @min, @max)
       @dispatcher.add(Puppet::Pops::Functions::Dispatch.new(callable_t, meth_name, @names, @max == :default, @block_name, @injections, @weaving, @argument_mismatch_hander))
     end
@@ -586,19 +590,16 @@ module Puppet::Functions
     end
 
     def internal_type_parse(type_string, loader)
-      begin
-        Puppet::Pops::Types::TypeParser.singleton.parse(type_string, loader)
-      rescue StandardError => e
-        raise ArgumentError, _("Parsing of type string '\"%{type_string}\"' failed with message: <%{message}>.\n") % {
-            type_string: type_string,
-            message: e.message
-        }
-      end
+      Puppet::Pops::Types::TypeParser.singleton.parse(type_string, loader)
+    rescue StandardError => e
+      raise ArgumentError, _("Parsing of type string '\"%{type_string}\"' failed with message: <%{message}>.\n") % {
+        type_string: type_string,
+        message: e.message
+      }
     end
     private :internal_type_parse
   end
 
-
   # The LocalTypeAliasBuilder is used by the 'local_types' method to collect the individual
   # type aliases given by the function's author.
   #
@@ -631,20 +632,20 @@ module Puppet::Functions
         rb_location = rb_location.gsub(/:in.*$/, '')
         # Create a meaningful location for parse errors - show both what went wrong with the parsing
         # and in which ruby file it was found.
-        raise ArgumentError, _("Parsing of 'type \"%{assignment_string}\"' failed with message: <%{message}>.\n" +
-          "Called from <%{ruby_file_location}>") % {
-            assignment_string: assignment_string,
-            message: e.message,
-            ruby_file_location: rb_location
-        }
+        raise ArgumentError, _("Parsing of 'type \"%{assignment_string}\"' failed with message: <%{message}>.\n" \
+                               "Called from <%{ruby_file_location}>") % {
+                                 assignment_string: assignment_string,
+                                 message: e.message,
+                                 ruby_file_location: rb_location
+                               }
       end
-      unless result.body.kind_of?(Puppet::Pops::Model::TypeAlias)
+      unless result.body.is_a?(Puppet::Pops::Model::TypeAlias)
         rb_location = rb_location.gsub(/:in.*$/, '')
-        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'.\n"+
-        "Called from <%{ruby_file_location}>") % {
-          assignment_string: assignment_string,
-          ruby_file_location: rb_location
-        }
+        raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'.\n" \
+                               "Called from <%{ruby_file_location}>") % {
+                                 assignment_string: assignment_string,
+                                 ruby_file_location: rb_location
+                               }
       end
       @local_types << result.body
     end
@@ -680,15 +681,14 @@ module Puppet::Functions
   end
 
   class Function3x < InternalFunction
-
     # Table of optimized parameter names - 0 to 5 parameters
     PARAM_NAMES = [
       [],
-      ['p0'.freeze].freeze,
-      ['p0'.freeze, 'p1'.freeze].freeze,
-      ['p0'.freeze, 'p1'.freeze, 'p2'.freeze].freeze,
-      ['p0'.freeze, 'p1'.freeze, 'p2'.freeze, 'p3'.freeze].freeze,
-      ['p0'.freeze, 'p1'.freeze, 'p2'.freeze, 'p3'.freeze, 'p4'.freeze].freeze,
+      ['p0'].freeze,
+      %w[p0 p1].freeze,
+      %w[p0 p1 p2].freeze,
+      %w[p0 p1 p2 p3].freeze,
+      %w[p0 p1 p2 p3 p4].freeze
     ]
 
     # Creates an anonymous Function3x class that wraps a 3x function
@@ -738,31 +738,28 @@ module Puppet::Functions
       # When function is not an rvalue function, make sure it produces nil
       #
       the_class.class_eval do
-
         # Bypasses making the  call via the dispatcher to make sure errors
         # are reported exactly the same way as in 3x. The dispatcher is still needed as it is
         # used to support other features than calling.
         #
         def call(scope, *args, &block)
+          result = catch(:return) do
+            mapped_args = Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.map_args(args, scope, '')
+            # this is the scope.function_xxx(...) call
+            return scope.send(self.class.method3x, mapped_args)
+          end
+          result.value
+        rescue Puppet::Pops::Evaluator::Next => jumper
           begin
-            result = catch(:return) do
-              mapped_args = Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.map_args(args, scope, '')
-              # this is the scope.function_xxx(...) call
-              return scope.send(self.class.method3x, mapped_args)
-            end
-            return result.value
-          rescue Puppet::Pops::Evaluator::Next => jumper
-            begin
-              throw :next, jumper.value
-            rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
-              raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
-            end
-          rescue Puppet::Pops::Evaluator::Return => jumper
-            begin
-              throw :return, jumper
-            rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
-              raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
-            end
+            throw :next, jumper.value
+          rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
+            raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
+          end
+        rescue Puppet::Pops::Evaluator::Return => jumper
+          begin
+            throw :return, jumper
+          rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION
+            raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
           end
         end
       end
@@ -795,12 +792,11 @@ module Puppet::Functions
       end
       # Names of parameters, up to 5 are optimized and use frozen version
       # Note that (0..count-1) produces expected empty array for count == 0, 0-n for count >= 1
-      names = count <= 5 ? PARAM_NAMES[count] : (0..count-1).map {|n| "p#{n}" }
+      names = count <= 5 ? PARAM_NAMES[count] : (0..count - 1).map { |n| "p#{n}" }
       [from, to, names]
     end
   end
 
-
   # Injection and Weaving of parameters
   # ---
   # It is possible to inject and weave a set of well known parameters into a call.
@@ -856,7 +852,7 @@ module Puppet::Functions
     def inject(injection_name)
       @injections << injection_name
       # mark what should be picked for this position when dispatching
-      @weaving << [@injections.size()-1]
+      @weaving << [@injections.size() - 1]
     end
   end
 end

data/lib/puppet/generate/models/type/property.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet
   module Generate
     module Models
@@ -59,8 +61,9 @@ module Puppet
             enum    = strings.empty? ? nil : "Enum[#{strings.join(', ')}]"
             pattern = regexes.empty? ? nil : "Pattern[#{regexes.join(', ')}]"
             boolean = strings.include?('\'true\'') || strings.include?('\'false\'') ? 'Boolean' : nil
-            variant = [boolean, enum, pattern].reject { |t| t.nil? }
+            variant = [boolean, enum, pattern].compact
             return variant[0] if variant.size == 1
+
             "Variant[#{variant.join(', ')}]"
           end
         end

data/lib/puppet/generate/models/type/type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../../puppet/generate/models/type/property'
 
 module Puppet
@@ -38,16 +40,17 @@ module Puppet
               Property.new(type.paramclass(name))
             end
             sc = Puppet::Pops::Types::StringConverter.singleton
-            @title_patterns = Hash[type.title_patterns.map do |mapping|
+            @title_patterns = type.title_patterns.to_h do |mapping|
               [
                 sc.convert(mapping[0], '%p'),
                 sc.convert(mapping[1].map do |names|
                   next if names.empty?
                   raise Puppet::Error, _('title patterns that use procs are not supported.') unless names.size == 1
+
                   names[0].to_s
                 end, '%p')
               ]
-            end]
+            end
             @isomorphic = type.isomorphic?
             # continue to emit capability as false when rendering the ERB
             # template, so that pcore modules generated prior to puppet7 can be

data/lib/puppet/generate/type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'erb'
 require 'fileutils'
 require_relative '../../puppet/util/autoload'
@@ -38,6 +40,7 @@ module Puppet
         def format=(format)
           format = format.to_sym
           raise _("unsupported format '%{format}'.") % { format: format } unless self.class.supported_format?(format)
+
           @format = format
         end
 
@@ -46,7 +49,7 @@ module Puppet
         # @return [Boolean] Returns true if the output is up-to-date or false if not.
         def up_to_date?(outputdir)
           f = effective_output_path(outputdir)
-          Puppet::FileSystem::exist?(f) && (Puppet::FileSystem::stat(@path) <=> Puppet::FileSystem::stat(f)) <= 0
+          Puppet::FileSystem.exist?(f) && (Puppet::FileSystem.stat(@path) <=> Puppet::FileSystem.stat(f)) <= 0
         end
 
         # Gets the filename of the output file.
@@ -125,18 +128,20 @@ module Puppet
           Puppet.debug "Searching '#{mod.name}' module for custom types."
           Dir.glob("#{directory}/*.rb") do |file|
             next unless Puppet::FileSystem.file?(file)
+
             Puppet.debug "Found custom type source file '#{file}'."
             inputs << Input.new(mod.path, file, format)
           end
         end
 
         # Sort the inputs by path
-        inputs.sort_by! { |input| input.path }
+        inputs.sort_by!(&:path)
       end
 
       def self.bad_input?
         @bad_input
       end
+
       # Generates files for the given inputs.
       # If a file is up to date (newer than input) it is kept.
       # If a file is out of date it is regenerated.
@@ -150,8 +155,8 @@ module Puppet
       def self.generate(inputs, outputdir = nil, force = false)
         # remove files for non existing inputs
         unless outputdir.nil?
-          filenames_to_keep = inputs.map {|i| i.output_name }
-          existing_files = Puppet::FileSystem.children(outputdir).map {|f| Puppet::FileSystem.basename(f) }
+          filenames_to_keep = inputs.map(&:output_name)
+          existing_files = Puppet::FileSystem.children(outputdir).map { |f| Puppet::FileSystem.basename(f) }
           files_to_remove = existing_files - filenames_to_keep
           files_to_remove.each do |f|
             Puppet::FileSystem.unlink(File.join(outputdir, f))
@@ -165,8 +170,9 @@ module Puppet
         end
 
         templates = {}
-        templates.default_proc = lambda { |hash, key|
+        templates.default_proc = lambda { |_hash, key|
           raise _("template was not found at '%{key}'.") % { key: key } unless Puppet::FileSystem.file?(key)
+
           template = Puppet::Util.create_erb(File.read(key))
           template.filename = key
           template

data/lib/puppet/gettext/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/util/platform'
 require_relative '../../puppet/file_system'
 
@@ -41,9 +43,9 @@ module Puppet::GettextConfig
   # @return [String] the active locale
   def self.current_locale
     if gettext_loaded?
-      return FastGettext.default_locale
+      FastGettext.default_locale
     else
-      return 'en'
+      'en'
     end
   end
 
@@ -53,7 +55,7 @@ module Puppet::GettextConfig
   def self.loaded_text_domains
     return [] if @gettext_disabled || !gettext_loaded?
 
-    return FastGettext.translation_repositories.keys
+    FastGettext.translation_repositories.keys
   end
 
   # @api private
@@ -63,6 +65,7 @@ module Puppet::GettextConfig
   # @param [String, Symbol] domain_name the name of the domain to create
   def self.reset_text_domain(domain_name)
     return if @gettext_disabled || !gettext_loaded?
+
     domain_name = domain_name.to_sym
 
     Puppet.debug { "Reset text domain to #{domain_name.inspect}" }
@@ -83,6 +86,7 @@ module Puppet::GettextConfig
   # non-default text domain.
   def self.clear_text_domain
     return if @gettext_disabled || !gettext_loaded?
+
     FastGettext.text_domain = nil
   end
 
@@ -112,6 +116,7 @@ module Puppet::GettextConfig
   # @param [String, Symbol] domain_name the name of the domain to switch to
   def self.use_text_domain(domain_name)
     return if @gettext_disabled || !gettext_loaded?
+
     domain_name = domain_name.to_sym
 
     if FastGettext.translation_repositories.include?(domain_name)
@@ -135,6 +140,7 @@ module Puppet::GettextConfig
   # @param [String, Symbol] domain_name the name of the domain to delete
   def self.delete_text_domain(domain_name)
     return if @gettext_disabled || !gettext_loaded?
+
     domain_name = domain_name.to_sym
 
     deleted = FastGettext.translation_repositories.delete(domain_name)
@@ -185,11 +191,11 @@ module Puppet::GettextConfig
   # @return [String] path to the config, or nil if not found
   def self.puppet_locale_path
     if Puppet::FileSystem.exist?(LOCAL_PATH)
-      return LOCAL_PATH
+      LOCAL_PATH
     elsif Puppet::Util::Platform.windows? && Puppet::FileSystem.exist?(WINDOWS_PATH)
-      return WINDOWS_PATH
+      WINDOWS_PATH
     elsif !Puppet::Util::Platform.windows? && Puppet::FileSystem.exist?(POSIX_PATH)
-      return POSIX_PATH
+      POSIX_PATH
     else
       nil
     end
@@ -201,9 +207,9 @@ module Puppet::GettextConfig
   # @return [Symbol] :mo if in a package structure, :po otherwise
   def self.translation_mode(conf_path)
     if WINDOWS_PATH == conf_path || POSIX_PATH == conf_path
-      return :mo
+      :mo
     else
-      return :po
+      :po
     end
   end
 
@@ -233,7 +239,7 @@ module Puppet::GettextConfig
     end
 
     add_repository_to_domain(project_name, locale_dir, file_format, text_domain)
-    return true
+    true
   end
 
   # @api private
@@ -267,6 +273,7 @@ module Puppet::GettextConfig
   # @param [String] locale the language portion of a locale string (e.g. "ja")
   def self.set_locale(locale)
     return if @gettext_disabled || !gettext_loaded?
+
     # make sure we're not using the `available_locales` machinery
     FastGettext.default_available_locales = nil
 

data/lib/puppet/gettext/module_translations.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/gettext/config'
 
 module Puppet::ModuleTranslations
-
   # @api private
   # Loads translation files for each of the specified modules,
   # if present. Requires the modules to have `forge_name` specified.