openvox 7.37.1 → 8.19.0

data/lib/puppet/pal/catalog_compiler.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet
 module Pal
   # A CatalogCompiler is a compiler that builds a catalog of resources and dependencies as a side effect of
@@ -8,7 +10,6 @@ module Pal
   #
   # @api public
   class CatalogCompiler < Compiler
-
     # @api private
     def catalog
       internal_compiler.catalog
@@ -62,7 +63,6 @@ module Pal
       end
     end
 
-
     # Compiles the result of additional evaluation taking place in a PAL catalog compilation.
     # This will evaluate all lazy constructs until all have been evaluated, and will the validate
     # the result.
@@ -103,6 +103,5 @@ module Pal
       internal_compiler.evaluate_ast_node
     end
   end
-
 end
 end

data/lib/puppet/pal/compiler.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Puppet
 module Pal
-
   # A configured compiler as obtained in the callback from `Puppet::Pal.with_script_compiler`.
   # (Later, there may also be a catalog compiler available.)
   #
@@ -24,8 +25,8 @@ module Pal
     #
     def call_function(function_name, *args, &block)
       # TRANSLATORS: do not translate variable name strings in these assertions
-      Pal::assert_non_empty_string(function_name, 'function_name', false)
-      Pal::assert_type(Pal::T_ANY_ARRAY, args, 'args', false)
+      Pal.assert_non_empty_string(function_name, 'function_name', false)
+      Pal.assert_type(Pal::T_ANY_ARRAY, args, 'args', false)
       internal_evaluator.evaluator.external_call_function(function_name, args, topscope, &block)
     end
 
@@ -45,6 +46,7 @@ module Pal
       if func
         return FunctionSignature.new(func.class)
       end
+
       # Could not find function
       nil
     end
@@ -86,6 +88,7 @@ module Pal
       unless puppet_code.is_a?(String)
         raise ArgumentError, _("The argument 'puppet_code' must be a String, got %{type}") % { type: puppet_code.class }
       end
+
       evaluate(parse_string(puppet_code, source_file))
     end
 
@@ -140,6 +143,7 @@ module Pal
       unless code_string.is_a?(String)
         raise ArgumentError, _("The argument 'code_string' must be a String, got %{type}") % { type: code_string.class }
       end
+
       internal_evaluator.parse_string(code_string, source_file)
     end
 
@@ -153,6 +157,7 @@ module Pal
       unless file.is_a?(String)
         raise ArgumentError, _("The argument 'file' must be a String, got %{type}") % { type: file.class }
       end
+
       internal_evaluator.parse_file(file)
     end
 
@@ -188,8 +193,9 @@ module Pal
     def create(data_type, *arguments)
       t = data_type.is_a?(String) ? type(data_type) : data_type
       unless t.is_a?(Puppet::Pops::Types::PAnyType)
-        raise ArgumentError, _("Given data_type value is not a data type, got '%{type}'") % {type: t.class}
+        raise ArgumentError, _("Given data_type value is not a data type, got '%{type}'") % { type: t.class }
       end
+
       call_function('new', t, *arguments)
     end
 
@@ -207,7 +213,7 @@ module Pal
       if filter_regex.nil?
         loader.discover(kind, error_collector)
       else
-        loader.discover(kind, error_collector) {|f| f.name =~ filter_regex }
+        loader.discover(kind, error_collector) { |f| f.name =~ filter_regex }
       end
     end
 
@@ -217,6 +223,5 @@ module Pal
       internal_compiler.topscope
     end
   end
-
 end
 end

data/lib/puppet/pal/function_signature.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet
 module Pal
   # A FunctionSignature is returned from `function_signature`. Its purpose is to answer questions about the function's parameters
@@ -25,12 +27,13 @@ module Pal
     # @return [Boolean] true if the function can be called with given args + block, and false otherwise
     # @api public
     #
-    def callable_with?(args, callable=nil)
+    def callable_with?(args, callable = nil)
       signatures = @func.dispatcher.to_type
       callables = signatures.is_a?(Puppet::Pops::Types::PVariantType) ? signatures.types : [signatures]
 
-      return true if callables.any? {|t| t.callable_with?(args) }
+      return true if callables.any? { |t| t.callable_with?(args) }
       return false unless block_given?
+
       args_type = Puppet::Pops::Types::TypeCalculator.singleton.infer_set(callable.nil? ? args : args + [callable])
       error_message = Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(@func.name, @func.signatures, args_type)
       yield error_message
@@ -47,6 +50,5 @@ module Pal
       signatures.is_a?(Puppet::Pops::Types::PVariantType) ? signatures.types : [signatures]
     end
   end
-
 end
 end

data/lib/puppet/pal/json_catalog_encoder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # The JsonCatalogEncoder is a wrapper around a catalog produced by the Pal::CatalogCompiler.with_json_encoding
 # method.
 # It allows encoding the entire catalog or an individual resource as Rich Data Json.
@@ -52,8 +54,10 @@ class JsonCatalogEncoder
     #
     # TRANSLATORS 'type' and 'title' are internal parameter names - do not translate
     raise ArgumentError, _("Both type and title must be given") if type.nil? or title.nil?
+
     r = possibly_filtered_catalog.resource(type, title)
     return nil if r.nil?
+
     r.to_data_hash.to_json(:pretty => pretty)
   end
 
@@ -61,11 +65,12 @@ class JsonCatalogEncoder
   # or the catalog itself if filtering was not needed.
   # The result is cached.
   # @api private
-  #
+  # rubocop:disable Naming/MemoizedInstanceVariableName
   def possibly_filtered_catalog
-    @filtered ||= (exclude_virtual ? catalog.filter { |r| r.virtual? } : catalog)
+    @filtered ||= (exclude_virtual ? catalog.filter(&:virtual?) : catalog)
   end
   private :possibly_filtered_catalog
+  # rubocop:enable Naming/MemoizedInstanceVariableName
 end
 end
 end

data/lib/puppet/pal/pal_api.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet
   require_relative '../../puppet/parser/script_compiler'
   require_relative '../../puppet/parser/catalog_compiler'

data/lib/puppet/pal/pal_impl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Puppet as a Library "PAL"
 
 # Yes, this requires all of puppet for now because 'settings' and many other things...
@@ -27,7 +29,6 @@ module Puppet
 #
 # @api public
 module Pal
-
   # Defines a context in which multiple operations in an env with a script compiler can be performed in a given block.
   # The calls that takes place to PAL inside of the given block are all with the same instance of the compiler.
   # The parameter `configured_by_env` makes it possible to either use the configuration in the environment, or specify
@@ -56,14 +57,14 @@ module Pal
   # @yieldparam [Puppet::Pal::ScriptCompiler] compiler, a ScriptCompiler to perform operations on.
   #
   def self.with_script_compiler(
-      configured_by_env: false,
-      manifest_file:     nil,
-      code_string:       nil,
-      facts:             {},
-      variables:         {},
-      set_local_facts:   true,
-      &block
-    )
+    configured_by_env: false,
+    manifest_file:     nil,
+    code_string:       nil,
+    facts:             {},
+    variables:         {},
+    set_local_facts:   true,
+    &block
+  )
     # TRANSLATORS: do not translate variable name strings in these assertions
     assert_mutually_exclusive(manifest_file, code_string, 'manifest_file', 'code_string')
     assert_non_empty_string(manifest_file, 'manifest_file', true)
@@ -75,15 +76,14 @@ module Pal
         # TRANSLATORS: do not translate the variable names in this error message
         raise ArgumentError, _("manifest_file or code_string cannot be given when configured_by_env is true")
       end
+
       # Use the manifest setting
       manifest_file = Puppet[:manifest]
-    else
+    elsif manifest_file.nil? && code_string.nil?
       # An "undef" code_string is the only way to override Puppet[:manifest] & Puppet[:code] settings since an
       # empty string is taken as Puppet[:code] not being set.
       #
-      if manifest_file.nil? && code_string.nil?
-        code_string = 'undef'
-      end
+      code_string = 'undef'
     end
 
     previous_tasks_value = Puppet[:tasks]
@@ -95,11 +95,11 @@ module Pal
     # If manifest_file is nil, the #main method will use the env configured manifest
     # to do things in the block while a Script Compiler is in effect
     main(
-      manifest:                manifest_file,
-      facts:                   facts,
-      variables:               variables,
+      manifest: manifest_file,
+      facts: facts,
+      variables: variables,
       internal_compiler_class: :script,
-      set_local_facts:         set_local_facts,
+      set_local_facts: set_local_facts,
       &block
     )
   ensure
@@ -163,12 +163,12 @@ module Pal
   #
   def self.with_catalog_compiler(
     configured_by_env: false,
-      manifest_file:     nil,
-      code_string:       nil,
-      facts:             {},
-      variables:         {},
-      target_variables:  {},
-      &block
+    manifest_file:     nil,
+    code_string:       nil,
+    facts:             {},
+    variables:         {},
+    target_variables:  {},
+    &block
   )
     # TRANSLATORS: do not translate variable name strings in these assertions
     assert_mutually_exclusive(manifest_file, code_string, 'manifest_file', 'code_string')
@@ -181,15 +181,14 @@ module Pal
         # TRANSLATORS: do not translate the variable names in this error message
         raise ArgumentError, _("manifest_file or code_string cannot be given when configured_by_env is true")
       end
+
       # Use the manifest setting
       manifest_file = Puppet[:manifest]
-    else
+    elsif manifest_file.nil? && code_string.nil?
       # An "undef" code_string is the only way to override Puppet[:manifest] & Puppet[:code] settings since an
       # empty string is taken as Puppet[:code] not being set.
       #
-      if manifest_file.nil? && code_string.nil?
-        code_string = 'undef'
-      end
+      code_string = 'undef'
     end
 
     # We need to make sure to set these back when we're done
@@ -203,12 +202,12 @@ module Pal
     # If manifest_file is nil, the #main method will use the env configured manifest
     # to do things in the block while a Script Compiler is in effect
     main(
-      manifest:                manifest_file,
-      facts:                   facts,
-      variables:               variables,
-      target_variables:        target_variables,
+      manifest: manifest_file,
+      facts: facts,
+      variables: variables,
+      target_variables: target_variables,
       internal_compiler_class: :catalog,
-      set_local_facts:         false,
+      set_local_facts: false,
       &block
     )
   ensure
@@ -229,12 +228,11 @@ module Pal
   # @yieldparam [Puppet::Pal] context, a context that responds to Puppet::Pal methods
   #
   def self.in_tmp_environment(env_name,
-      modulepath:    [],
-      settings_hash: {},
-      facts:         nil,
-      variables:     {},
-      &block
-    )
+                              modulepath:    [],
+                              settings_hash: {},
+                              facts:         nil,
+                              variables:     {},
+                              &block)
     assert_non_empty_string(env_name, _("temporary environment name"))
     # TRANSLATORS: do not translate variable name string in these assertions
     assert_optionally_empty_array(modulepath, 'modulepath')
@@ -248,7 +246,7 @@ module Pal
     in_environment_context(
       Puppet::Environments::Static.new(env), # The tmp env is the only known env
       env, facts, variables, &block
-      )
+    )
   end
 
   # Defines the context in which to perform puppet operations (evaluation, etc)
@@ -277,16 +275,15 @@ module Pal
   #
   # @api public
   def self.in_environment(env_name,
-      modulepath:    nil,
-      pre_modulepath: [],
-      post_modulepath: [],
-      settings_hash: {},
-      env_dir:       nil,
-      envpath:       nil,
-      facts:         nil,
-      variables:     {},
-      &block
-    )
+                          modulepath: nil,
+                          pre_modulepath: [],
+                          post_modulepath: [],
+                          settings_hash: {},
+                          env_dir:       nil,
+                          envpath:       nil,
+                          facts:         nil,
+                          variables:     {},
+                          &block)
     # TRANSLATORS terms in the assertions below are names of terms in code
     assert_non_empty_string(env_name, 'env_name')
     assert_optionally_empty_array(modulepath, 'modulepath', true)
@@ -325,6 +322,7 @@ module Pal
       if env.nil?
         raise ArgumentError, _("No directory found for the environment '%{env_name}' on the path '%{envpath}'") % { env_name: env_name, envpath: envpath }
       end
+
       # A given modulepath should override the default
       mid_modulepath = modulepath.nil? ? env.modulepath : modulepath
       env_path = env.configuration.path_to_env
@@ -381,7 +379,7 @@ module Pal
     end
 
     rich_data_t = Puppet::Pops::Types::TypeFactory.rich_data
-    variables.each_pair do |k,v|
+    variables.each_pair do |k, v|
       unless k =~ Puppet::Pops::Patterns::VAR_NAME
         raise ArgumentError, _("Given variable '%{varname}' has illegal name") % { varname: k }
       end
@@ -444,67 +442,63 @@ module Pal
     node.environment = apply_environment
 
     # TRANSLATORS, the string "For puppet PAL" is not user facing
-    Puppet.override({:current_environment => apply_environment}, "For puppet PAL") do
-      begin
-        node.sanitize()
-        compiler = create_internal_compiler(internal_compiler_class, node)
-
-        case internal_compiler_class
-        when :script
-          pal_compiler = ScriptCompiler.new(compiler)
-          overrides[:pal_script_compiler] = overrides[:pal_compiler] = pal_compiler
-        when :catalog
-          pal_compiler = CatalogCompiler.new(compiler)
-          overrides[:pal_catalog_compiler] = overrides[:pal_compiler] = pal_compiler
-        end
+    Puppet.override({ :current_environment => apply_environment }, "For puppet PAL") do
+      node.sanitize()
+      compiler = create_internal_compiler(internal_compiler_class, node)
+
+      case internal_compiler_class
+      when :script
+        pal_compiler = ScriptCompiler.new(compiler)
+        overrides[:pal_script_compiler] = overrides[:pal_compiler] = pal_compiler
+      when :catalog
+        pal_compiler = CatalogCompiler.new(compiler)
+        overrides[:pal_catalog_compiler] = overrides[:pal_compiler] = pal_compiler
+      end
 
-        # When scripting the trusted data are always local; default is to set them anyway
-        # When compiling for a catalog, the catalog compiler does this
-        if set_local_facts
-          compiler.topscope.set_trusted(node.trusted_data)
+      # When scripting the trusted data are always local; default is to set them anyway
+      # When compiling for a catalog, the catalog compiler does this
+      if set_local_facts
+        compiler.topscope.set_trusted(node.trusted_data)
 
-          # Server facts are always about the local node's version etc.
-          compiler.topscope.set_server_facts(node.server_facts)
+        # Server facts are always about the local node's version etc.
+        compiler.topscope.set_server_facts(node.server_facts)
 
-          # Set $facts for the node running the script
-          facts_hash = node.facts.nil? ? {} : node.facts.values
-          compiler.topscope.set_facts(facts_hash)
+        # Set $facts for the node running the script
+        facts_hash = node.facts.nil? ? {} : node.facts.values
+        compiler.topscope.set_facts(facts_hash)
 
-          # create the $settings:: variables
-          compiler.topscope.merge_settings(node.environment.name, false)
-        end
+        # create the $settings:: variables
+        compiler.topscope.merge_settings(node.environment.name, false)
+      end
 
-        # Make compiler available to Puppet#lookup and injection in functions
-        # TODO: The compiler instances should be available under non PAL use as well!
-        # TRANSLATORS: Do not translate, symbolic name
-        Puppet.override(overrides, "PAL::with_#{internal_compiler_class}_compiler") do
-          compiler.compile do | compiler_yield |
-            # In case the variables passed to the compiler are PCore types defined in modules, they
-            # need to be deserialized and added from within the this scope, so that loaders are
-            # available during deserizlization.
-            pal_variables = Puppet::Pops::Serialization::FromDataConverter.convert(pal_variables)
-            variables     = Puppet::Pops::Serialization::FromDataConverter.convert(variables)
-
-            # Merge together target variables and plan variables. This will also shadow any
-            # collisions with facts and emit a warning.
-            topscope_vars = pal_variables.merge(merge_vars(target_variables, variables, node.facts.values))
-
-            add_variables(compiler.topscope, topscope_vars)
-            # wrap the internal compiler to prevent it from leaking in the PAL API
-            if block_given?
-              yield(pal_compiler)
-            end
+      # Make compiler available to Puppet#lookup and injection in functions
+      # TODO: The compiler instances should be available under non PAL use as well!
+      # TRANSLATORS: Do not translate, symbolic name
+      Puppet.override(overrides, "PAL::with_#{internal_compiler_class}_compiler") do
+        compiler.compile do |_compiler_yield|
+          # In case the variables passed to the compiler are PCore types defined in modules, they
+          # need to be deserialized and added from within the this scope, so that loaders are
+          # available during deserizlization.
+          pal_variables = Puppet::Pops::Serialization::FromDataConverter.convert(pal_variables)
+          variables     = Puppet::Pops::Serialization::FromDataConverter.convert(variables)
+
+          # Merge together target variables and plan variables. This will also shadow any
+          # collisions with facts and emit a warning.
+          topscope_vars = pal_variables.merge(merge_vars(target_variables, variables, node.facts.values))
+
+          add_variables(compiler.topscope, topscope_vars)
+          # wrap the internal compiler to prevent it from leaking in the PAL API
+          if block_given?
+            yield(pal_compiler)
           end
         end
-
-      rescue Puppet::Error
-        # already logged and handled by the compiler, including Puppet::ParseErrorWithIssue
-        raise
-
-      rescue => detail
-        Puppet.log_exception(detail)
-        raise
       end
+    rescue Puppet::Error
+      # already logged and handled by the compiler, including Puppet::ParseErrorWithIssue
+      raise
+    rescue => detail
+      Puppet.log_exception(detail)
+      raise
     end
   end
   private_class_method :main
@@ -558,17 +552,18 @@ module Pal
   T_BOOLEAN = Puppet::Pops::Types::PBooleanType::DEFAULT
 
   T_GENERIC_TASK_HASH = Puppet::Pops::Types::TypeFactory.hash_kv(
-    Puppet::Pops::Types::TypeFactory.pattern(/\A[a-z][a-z0-9_]*\z/), Puppet::Pops::Types::TypeFactory.data)
+    Puppet::Pops::Types::TypeFactory.pattern(/\A[a-z][a-z0-9_]*\z/), Puppet::Pops::Types::TypeFactory.data
+  )
 
-  def self.assert_type(type, value, what, allow_nil=false)
-    Puppet::Pops::Types::TypeAsserter.assert_instance_of(nil, type, value, allow_nil) { _('Puppet Pal: %{what}') % {what: what} }
+  def self.assert_type(type, value, what, allow_nil = false)
+    Puppet::Pops::Types::TypeAsserter.assert_instance_of(nil, type, value, allow_nil) { _('Puppet Pal: %{what}') % { what: what } }
   end
 
-  def self.assert_non_empty_string(s, what, allow_nil=false)
+  def self.assert_non_empty_string(s, what, allow_nil = false)
     assert_type(T_STRING, s, what, allow_nil)
   end
 
-  def self.assert_optionally_empty_array(a, what, allow_nil=false)
+  def self.assert_optionally_empty_array(a, what, allow_nil = false)
     assert_type(T_STRING_ARRAY, a, what, allow_nil)
   end
   private_class_method :assert_optionally_empty_array

data/lib/puppet/pal/plan_signature.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet
 module Pal
   # A PlanSignature is returned from `plan_signature`. Its purpose is to answer questions about the plans's parameters
@@ -47,8 +49,9 @@ module Pal
 
       errors = Puppet::Pops::Types::TypeMismatchDescriber.singleton.describe_struct_signature(dispatcher.params_struct, param_scope).flatten
       return true if errors.empty?
+
       if block_given?
-        yield errors.map {|e| e.format }.join("\n")
+        yield errors.map(&:format).join("\n")
       end
       false
     end
@@ -66,6 +69,5 @@ module Pal
       dispatcher.params_struct
     end
   end
-
 end
 end

data/lib/puppet/pal/script_compiler.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Puppet
 module Pal
-
   class ScriptCompiler < Compiler
     # Returns the signature of the given plan name
     # @param plan_name [String] the name of the plan to get the signature of
@@ -12,6 +13,7 @@ module Pal
       if func
         return PlanSignature.new(func)
       end
+
       # Could not find plan
       nil
     end
@@ -45,6 +47,7 @@ module Pal
       if task
         return TaskSignature.new(task)
       end
+
       # Could not find task
       nil
     end
@@ -68,6 +71,5 @@ module Pal
       list_loadable_kind(:task, filter_regex, error_collector)
     end
   end
-
 end
 end

data/lib/puppet/pal/task_signature.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet
 module Pal
   # A TaskSignature is returned from `task_signature`. Its purpose is to answer questions about the task's parameters
@@ -20,19 +22,24 @@ module Pal
     def runnable_with?(args_hash)
       params = @task.parameters
       params_type = if params.nil?
-        T_GENERIC_TASK_HASH
-      else
-        Puppet::Pops::Types::TypeFactory.struct(params)
-      end
+                      T_GENERIC_TASK_HASH
+                    else
+                      Puppet::Pops::Types::TypeFactory.struct(params)
+                    end
       return true if params_type.instance?(args_hash)
 
       if block_given?
         tm = Puppet::Pops::Types::TypeMismatchDescriber.singleton
         error = if params.nil?
-          tm.describe_mismatch('', params_type, Puppet::Pops::Types::TypeCalculator.infer_set(args_hash))
-        else
-          tm.describe_struct_signature(params_type, args_hash).flatten.map {|e| e.format }.join("\n")
-        end
+                  tm.describe_mismatch('', params_type,
+                                       Puppet::Pops::Types::TypeCalculator
+                                         .infer_set(args_hash))
+                else
+                  tm.describe_struct_signature(params_type, args_hash)
+                    .flatten
+                    .map(&:format)
+                    .join("\n")
+                end
         yield "Task #{@task.name}:\n#{error}"
       end
       false
@@ -53,6 +60,5 @@ module Pal
       @task
     end
   end
-
 end
 end

data/lib/puppet/parameter/boolean.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/coercion'
 
 # This specialized {Puppet::Parameter} handles Boolean options, accepting lots

data/lib/puppet/parameter/package_options.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/parameter'
 
 # This specialized {Puppet::Parameter} handles munging of package options.
@@ -26,6 +28,6 @@ class Puppet::Parameter::PackageOptions < Puppet::Parameter
 
   # @api private
   def quote(value)
-    value.include?(' ') ? %Q["#{value.gsub(/"/, '\"')}"] : value
+    value.include?(' ') ? %Q("#{value.gsub(/"/, '\"')}") : value
   end
 end

data/lib/puppet/parameter/path.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../puppet/parameter'
 
 # This specialized {Puppet::Parameter} handles validation and munging of paths.
@@ -11,6 +13,7 @@ class Puppet::Parameter::Path < Puppet::Parameter
   def self.accept_arrays(bool = true)
     @accept_arrays = !!bool
   end
+
   def self.arrays?
     @accept_arrays
   end
@@ -23,11 +26,11 @@ class Puppet::Parameter::Path < Puppet::Parameter
   # @return [Array<String>] the given paths
   #
   def validate_path(paths)
-    if paths.is_a?(Array) and ! self.class.arrays? then
+    if paths.is_a?(Array) and !self.class.arrays? then
       fail _("%{name} only accepts a single path, not an array of paths") % { name: name }
     end
 
-    fail(_("%{name} must be a fully qualified path") % { name: name }) unless Array(paths).all? {|path| absolute_path?(path)}
+    fail(_("%{name} must be a fully qualified path") % { name: name }) unless Array(paths).all? { |path| absolute_path?(path) }
 
     paths
   end
@@ -49,9 +52,10 @@ class Puppet::Parameter::Path < Puppet::Parameter
   # @return [String, Array<String>] the given paths
   # @raise [Puppet::Error] if the given paths does not comply with the on/many paths rule.
   def unsafe_munge(paths)
-    if paths.is_a?(Array) and ! self.class.arrays? then
+    if paths.is_a?(Array) and !self.class.arrays? then
       fail _("%{name} only accepts a single path, not an array of paths") % { name: name }
     end
+
     paths
   end
 end