openvox 7.37.1 → 8.19.0

data/lib/puppet/pops/evaluator/collector_transformer.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
 class CollectorTransformer
-
   def initialize
     @@query_visitor    ||= Visitor.new(nil, "query", 1, 1)
     @@match_visitor    ||= Visitor.new(nil, "match", 1, 1)
@@ -10,10 +11,11 @@ class CollectorTransformer
   end
 
   def transform(o, scope)
-    #TRANSLATORS 'CollectExpression' is a class name and should not be translated
+    # TRANSLATORS 'CollectExpression' is a class name and should not be translated
     raise ArgumentError, _("Expected CollectExpression") unless o.is_a? Model::CollectExpression
 
     raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
+
     type = o.type_expr.value().downcase()
 
     if type == 'class'
@@ -24,13 +26,13 @@ class CollectorTransformer
 
     fail "Resource type #{type} doesn't exist" unless resource_type
 
-    if !o.operations.empty?
+    unless o.operations.empty?
       overrides = {
-        :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
-        :file       => o.file,
-        :line       => o.line,
-        :source     => scope.source,
-        :scope      => scope
+        :parameters => o.operations.map { |x| @@evaluator.evaluate(x, scope) }.flatten,
+        :file => o.file,
+        :line => o.line,
+        :source => scope.source,
+        :scope => scope
       }
     end
 
@@ -49,7 +51,7 @@ class CollectorTransformer
     newcoll
   end
 
-protected
+  protected
 
   def query(o, scope)
     @@query_visitor.visit_this_1(self, o, scope)
@@ -99,10 +101,11 @@ protected
         if right_code.is_a?(Array)
           tags = right_code
         else
-          tags = [ right_code ]
+          tags = [right_code]
         end
         tags = tags.collect do |t|
           raise ArgumentError, _('Cannot transform a number to a tag') if t.is_a?(Numeric)
+
           t.to_s.downcase
         end
         proc do |resource|
@@ -161,7 +164,7 @@ protected
   end
 
   def query_ParenthesizedExpression(o, scope)
-   query(o.expr, scope)
+    query(o.expr, scope)
   end
 
   def query_Object(o, scope)
@@ -179,19 +182,19 @@ protected
   def match_AndExpression(o, scope)
     left_match = match(o.left_expr, scope)
     right_match = match(o.right_expr, scope)
-    return [left_match, 'and', right_match]
+    [left_match, 'and', right_match]
   end
 
   def match_OrExpression(o, scope)
     left_match = match(o.left_expr, scope)
     right_match = match(o.right_expr, scope)
-    return [left_match, 'or', right_match]
+    [left_match, 'or', right_match]
   end
 
   def match_ComparisonExpression(o, scope)
     left_match = match(o.left_expr, scope)
     right_match = match(o.right_expr, scope)
-    return [left_match, o.operator.to_s, right_match]
+    [left_match, o.operator.to_s, right_match]
   end
 
   def match_VariableExpression(o, scope)
@@ -223,7 +226,7 @@ protected
   end
 
   def match_ParenthesizedExpression(o, scope)
-   match(o.expr, scope)
+    match(o.expr, scope)
   end
 
   def match_Object(o, scope)

data/lib/puppet/pops/evaluator/collectors/abstract_collector.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Puppet::Pops::Evaluator::Collectors::AbstractCollector
   attr_reader :scope
 
@@ -26,7 +28,7 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
     @collected = {}
     @scope = scope
 
-    if !(overrides.nil? || overrides[:parameters])
+    unless overrides.nil? || overrides[:parameters]
       raise ArgumentError, _("Exported resource try to override without parameters")
     end
 
@@ -48,12 +50,12 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
       overrides[:source].override = true
 
       objects.each do |res|
-        unless @collected.include?(res.ref)
-          t = res.type
-          t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t)
-          newres = Puppet::Parser::Resource.new(t, res.title, @overrides)
-          scope.compiler.add_override(newres)
-        end
+        next if @collected.include?(res.ref)
+
+        t = res.type
+        t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t)
+        newres = Puppet::Parser::Resource.new(t, res.title, @overrides)
+        scope.compiler.add_override(newres)
       end
     end
 
@@ -61,7 +63,7 @@ class Puppet::Pops::Evaluator::Collectors::AbstractCollector
 
     return false if objects.empty?
 
-    objects.reduce(@collected) { |c,o| c[o.ref]=o; c }
+    objects.each_with_object(@collected) { |o, c| c[o.ref] = o; }
 
     objects
   end

data/lib/puppet/pops/evaluator/collectors/catalog_collector.rb

@@ -1,6 +1,7 @@
-class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
+# frozen_string_literal: true
 
-  # Creates a CatalogCollector using the AbstractCollector's 
+class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
+  # Creates a CatalogCollector using the AbstractCollector's
   # constructor to set the scope and overrides
   #
   # param [Puppet::CompilableResourceType] type the resource type to be collected
@@ -19,7 +20,7 @@ class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Eval
     q = @query
 
     scope.compiler.resources.find_all do |resource|
-      resource.type == t && (q ?  q.call(resource) : true)
+      resource.type == t && (q ? q.call(resource) : true)
     end
   end
 

data/lib/puppet/pops/evaluator/collectors/exported_collector.rb

@@ -1,5 +1,6 @@
-class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
+# frozen_string_literal: true
 
+class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
   # Creates an ExportedCollector using the AbstractCollector's
   # constructor to set the scope and overrides
   #
@@ -38,17 +39,17 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
         resource.type == t && resource.exported? && (q.nil? || q.call(resource))
       end
 
-      found = Puppet::Resource.indirection.
-        search(@type, :host => @scope.compiler.node.name, :filter => @equery, :scope => @scope)
+      found = Puppet::Resource.indirection
+                              .search(@type, :host => @scope.compiler.node.name, :filter => @equery, :scope => @scope)
 
-      found_resources = found.map {|x| x.is_a?(Puppet::Parser::Resource) ? x : x.to_resource(@scope)}
+      found_resources = found.map { |x| x.is_a?(Puppet::Parser::Resource) ? x : x.to_resource(@scope) }
 
       found_resources.each do |item|
         existing = @scope.findresource(item.resource_type, item.title)
         if existing
           unless existing.collector_id == item.collector_id
             raise Puppet::ParseError,
-              _("A duplicate resource was found while collecting exported resources, with the type and title %{title}") % { title: item.ref }
+                  _("A duplicate resource was found while collecting exported resources, with the type and title %{title}") % { title: item.ref }
           end
         else
           item.exported = false

data/lib/puppet/pops/evaluator/collectors/fixed_set_collector.rb

@@ -1,5 +1,6 @@
-class Puppet::Pops::Evaluator::Collectors::FixedSetCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
+# frozen_string_literal: true
 
+class Puppet::Pops::Evaluator::Collectors::FixedSetCollector < Puppet::Pops::Evaluator::Collectors::AbstractCollector
   # Creates a FixedSetCollector using the AbstractCollector constructor
   # to set the scope. It is not possible for a collection to have
   # overrides in this case, since we have a fixed set of resources that
@@ -8,24 +9,23 @@ class Puppet::Pops::Evaluator::Collectors::FixedSetCollector < Puppet::Pops::Eva
   # @param [Array] resources the fixed set of resources we want to realize
   def initialize(scope, resources)
     super(scope)
-    @resources = resources.is_a?(Array)? resources.dup : [resources]
+    @resources = resources.is_a?(Array) ? resources.dup : [resources]
   end
 
   # Collects a fixed set of resources and realizes them. Used
   # by the realize function
   def collect
     resolved = []
-    result = @resources.reduce([]) do |memo, ref|
+    result = @resources.each_with_object([]) do |ref, memo|
       res = @scope.findresource(ref.to_s)
-      if res
-        res.virtual = false
-        memo << res
-        resolved << ref
-      end
-      memo
+      next unless res
+
+      res.virtual = false
+      memo << res
+      resolved << ref
     end
 
-    @resources = @resources - resolved
+    @resources -= resolved
 
     @scope.compiler.delete_collection(self) if @resources.empty?
 

data/lib/puppet/pops/evaluator/compare_operator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Evaluator
 # Compares the puppet DSL way
@@ -47,22 +49,25 @@ class CompareOperator
 
   def cmp_String(a, b)
     return a.casecmp(b) if b.is_a?(String)
-    raise ArgumentError.new(_("A String is not comparable to a non String"))
+
+    raise ArgumentError, _("A String is not comparable to a non String")
   end
 
   # Equality is case independent.
   def equals_String(a, b)
     return false unless b.is_a?(String)
+
     a.casecmp(b) == 0
   end
 
   def cmp_Numeric(a, b)
-    if b.is_a?(Numeric)
+    case b
+    when Numeric
       a <=> b
-    elsif b.is_a?(Time::Timespan) || b.is_a?(Time::Timestamp)
+    when Time::Timespan, Time::Timestamp
       -(b <=> a) # compare other way and invert result
     else
-      raise ArgumentError.new(_("A Numeric is not comparable to non Numeric"))
+      raise ArgumentError, _("A Numeric is not comparable to non Numeric")
     end
   end
 
@@ -76,13 +81,15 @@ class CompareOperator
 
   def equals_Array(a, b)
     return false unless b.is_a?(Array) && a.size == b.size
-    a.each_index {|i| return false unless equals(a.slice(i), b.slice(i)) }
+
+    a.each_index { |i| return false unless equals(a.slice(i), b.slice(i)) }
     true
   end
 
   def equals_Hash(a, b)
     return false unless b.is_a?(Hash) && a.size == b.size
-    a.each {|ak, av| return false unless equals(b[ak], av)}
+
+    a.each { |ak, av| return false unless equals(b[ak], av) }
     true
   end
 
@@ -90,30 +97,32 @@ class CompareOperator
     if b.is_a?(Symbol)
       a <=> b
     else
-      raise ArgumentError.new(_("Symbol not comparable to non Symbol"))
+      raise ArgumentError, _("Symbol not comparable to non Symbol")
     end
   end
 
   def cmp_Timespan(a, b)
-    raise ArgumentError.new(_('Timespans are only comparable to Timespans, Integers, and Floats')) unless b.is_a?(Time::Timespan) ||  b.is_a?(Integer) || b.is_a?(Float)
+    raise ArgumentError, _('Timespans are only comparable to Timespans, Integers, and Floats') unless b.is_a?(Time::Timespan) || b.is_a?(Integer) || b.is_a?(Float)
+
     a <=> b
   end
 
   def cmp_Timestamp(a, b)
-    raise ArgumentError.new(_('Timestamps are only comparable to Timestamps, Integers, and Floats')) unless b.is_a?(Time::Timestamp) ||  b.is_a?(Integer) || b.is_a?(Float)
+    raise ArgumentError, _('Timestamps are only comparable to Timestamps, Integers, and Floats') unless b.is_a?(Time::Timestamp) || b.is_a?(Integer) || b.is_a?(Float)
+
     a <=> b
   end
 
   def cmp_Version(a, b)
-    raise ArgumentError.new(_('Versions not comparable to non Versions')) unless b.is_a?(SemanticPuppet::Version)
+    raise ArgumentError, _('Versions not comparable to non Versions') unless b.is_a?(SemanticPuppet::Version)
+
     a <=> b
   end
 
   def cmp_Object(a, b)
-    raise ArgumentError.new(_('Only Strings, Numbers, Timespans, Timestamps, and Versions are comparable'))
+    raise ArgumentError, _('Only Strings, Numbers, Timespans, Timestamps, and Versions are comparable')
   end
 
-
   def equals_Object(a, b)
     a == b
   end
@@ -168,20 +177,21 @@ class CompareOperator
       matched = nil
       a.each do |element|
         next unless element.is_a? String
+
         matched = element.match(b) # nil, or MatchData
         break if matched
       end
       # Always set match data, a "not found" should not keep old match data visible
       set_match_data(matched, scope) # creates ephemeral
-      return !!matched
+      !!matched
     when String, SemanticPuppet::Version
       a.any? { |element| match(b, element, scope) }
     when Types::PAnyType
-      a.each {|element| return true if b.instance?(element) }
-      return false
+      a.each { |element| return true if b.instance?(element) }
+      false
     else
-      a.each {|element| return true if equals(element, b) }
-      return false
+      a.each { |element| return true if equals(element, b) }
+      false
     end
   end
 
@@ -201,6 +211,7 @@ class CompareOperator
   # Matches only against strings
   def match_Regexp(regexp, left, scope)
     return false unless left.is_a? String
+
     matched = regexp.match(left)
     set_match_data(matched, scope) unless scope.nil? # creates or clears ephemeral
     !!matched # convert to boolean
@@ -208,9 +219,10 @@ class CompareOperator
 
   # Matches against semvers and strings
   def match_Version(version, left, scope)
-    if left.is_a?(SemanticPuppet::Version)
+    case left
+    when SemanticPuppet::Version
       version == left
-    elsif left.is_a? String
+    when String
       begin
         version == SemanticPuppet::Version.parse(left)
       rescue ArgumentError
@@ -237,16 +249,19 @@ class CompareOperator
   def match_Array(array, left, scope)
     return false unless left.is_a?(Array)
     return false unless left.length == array.length
-    array.each_with_index.all? { | pattern, index| match(left[index], pattern, scope) }
+
+    array.each_with_index.all? { |pattern, index| match(left[index], pattern, scope) }
   end
 
   def match_Hash(hash, left, scope)
     return false unless left.is_a?(Hash)
-    hash.all? {|x,y| match(left[x], y, scope) }
+
+    hash.all? { |x, y| match(left[x], y, scope) }
   end
 
   def match_Symbol(symbol, left, scope)
     return true if symbol == :default
+
     equals(left, default)
   end
 end

data/lib/puppet/pops/evaluator/deferred_resolver.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/parser/script_compiler'
 
 module Puppet::Pops
 module Evaluator
-
 class DeferredValue
   def initialize(proc)
     @proc = proc
@@ -22,8 +23,8 @@ end
 # Utility class to help resolve instances of Puppet::Pops::Types::PDeferredType::Deferred
 #
 class DeferredResolver
-  DOLLAR = '$'.freeze
-  DIG    = 'dig'.freeze
+  DOLLAR = '$'
+  DIG    = 'dig'
 
   # Resolves and replaces all Deferred values in a catalog's resource attributes
   # found as direct values or nested inside Array, Hash or Sensitive values.
@@ -110,7 +111,7 @@ class DeferredResolver
             mark_sensitive_parameters(r, k)
           end
         end
-        overrides[ k ] = resolved
+        overrides[k] = resolved
       end
       r.parameters.merge!(overrides) unless overrides.empty?
     end
@@ -151,13 +152,13 @@ class DeferredResolver
   private :mark_sensitive_parameters
 
   def resolve(x)
-    if x.class == @deferred_class
+    if x.instance_of?(@deferred_class)
       resolve_future(x)
     elsif x.is_a?(Array)
-      x.map {|v| resolve(v) }
+      x.map { |v| resolve(v) }
     elsif x.is_a?(Hash)
       result = {}
-      x.each_pair {|k,v| result[k] = resolve(v) }
+      x.each_pair { |k, v| result[k] = resolve(v) }
       result
     elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
       # rewrap in a new Sensitive after resolving any nested deferred values
@@ -171,15 +172,16 @@ class DeferredResolver
   end
 
   def resolve_lazy_args(x)
-    if x.is_a?(DeferredValue)
+    case x
+    when DeferredValue
       x.resolve
-    elsif x.is_a?(Array)
-      x.map {|v| resolve_lazy_args(v) }
-    elsif x.is_a?(Hash)
+    when Array
+      x.map { |v| resolve_lazy_args(v) }
+    when Hash
       result = {}
-      x.each_pair {|k,v| result[k] = resolve_lazy_args(v) }
+      x.each_pair { |k, v| result[k] = resolve_lazy_args(v) }
       result
-    elsif x.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+    when Puppet::Pops::Types::PSensitiveType::Sensitive
       # rewrap in a new Sensitive after resolving any nested deferred values
       Puppet::Pops::Types::PSensitiveType::Sensitive.new(resolve_lazy_args(x.unwrap))
     else
@@ -194,7 +196,7 @@ class DeferredResolver
     mapped_arguments = map_arguments(f.arguments)
     # if name starts with $ then this is a call to dig
     if func_name[0] == DOLLAR
-      var_name = func_name[1..-1]
+      var_name = func_name[1..]
       func_name = DIG
       mapped_arguments.insert(0, @scope[var_name])
     end
@@ -205,7 +207,7 @@ class DeferredResolver
     else
       # call the function later
       DeferredValue.new(
-        Proc.new {
+        proc {
           # deferred functions can have nested deferred arguments
           resolved_arguments = mapped_arguments.map { |arg| resolve_lazy_args(arg) }
           @scope.call_function(func_name, resolved_arguments)
@@ -216,10 +218,10 @@ class DeferredResolver
 
   def map_arguments(args)
     return [] if args.nil?
-    args.map {|v| resolve(v) }
+
+    args.map { |v| resolve(v) }
   end
   private :map_arguments
-
 end
 end
 end

data/lib/puppet/pops/evaluator/epp_evaluator.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 # Handler of Epp call/evaluation from the epp and inline_epp functions
 #
 class Puppet::Pops::Evaluator::EppEvaluator
-
   def self.inline_epp(scope, epp_source, template_args = nil)
     unless epp_source.is_a?(String)
-      #TRANSLATORS 'inline_epp()' is a method name and 'epp' refers to 'Embedded Puppet (EPP) template' and should not be translated
+      # TRANSLATORS 'inline_epp()' is a method name and 'epp' refers to 'Embedded Puppet (EPP) template' and should not be translated
       raise ArgumentError, _("inline_epp(): the first argument must be a String with the epp source text, got a %{class_name}") %
-          { class_name: epp_source.class }
+                           { class_name: epp_source.class }
     end
 
     # Parse and validate the source
@@ -14,7 +15,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
     begin
       result = parser.parse_string(epp_source, 'inlined-epp-text')
     rescue Puppet::ParseError => e
-      #TRANSLATORS 'inline_epp()' is a method name and 'EPP' refers to 'Embedded Puppet (EPP) template' and should not be translated
+      # TRANSLATORS 'inline_epp()' is a method name and 'EPP' refers to 'Embedded Puppet (EPP) template' and should not be translated
       raise ArgumentError, _("inline_epp(): Invalid EPP: %{detail}") % { detail: e.message }
     end
 
@@ -24,19 +25,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
 
   def self.epp(scope, file, env_name, template_args = nil)
     unless file.is_a?(String)
-      #TRANSLATORS 'epp()' is a method name and should not be translated
+      # TRANSLATORS 'epp()' is a method name and should not be translated
       raise ArgumentError, _("epp(): the first argument must be a String with the filename, got a %{class_name}") % { class_name: file.class }
     end
 
     unless Puppet::FileSystem.exist?(file)
       unless file =~ /\.epp$/
-        file = file + ".epp"
+        file += ".epp"
       end
     end
 
     scope.debug "Retrieving epp template #{file}"
     template_file = Puppet::Parser::Files.find_template(file, env_name)
-    if template_file.nil? ||  !Puppet::FileSystem.exist?(template_file)
+    if template_file.nil? || !Puppet::FileSystem.exist?(template_file)
       raise Puppet::ParseError, _("Could not find template '%{file}'") % { file: file }
     end
 
@@ -45,7 +46,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
     begin
       result = parser.parse_file(template_file)
     rescue Puppet::ParseError => e
-      #TRANSLATORS 'epp()' is a method name and 'EPP' refers to 'Embedded Puppet (EPP) template' and should not be translated
+      # TRANSLATORS 'epp()' is a method name and 'EPP' refers to 'Embedded Puppet (EPP) template' and should not be translated
       raise ArgumentError, _("epp(): Invalid EPP: %{detail}") % { detail: e.message }
     end
 
@@ -58,19 +59,19 @@ class Puppet::Pops::Evaluator::EppEvaluator
 
     body = parse_result.body
     unless body.is_a?(Puppet::Pops::Model::LambdaExpression)
-      #TRANSLATORS 'LambdaExpression' is a class name and should not be translated
+      # TRANSLATORS 'LambdaExpression' is a class name and should not be translated
       raise ArgumentError, _("%{function_name}(): the parser did not produce a LambdaExpression, got '%{class_name}'") %
-          { function_name: func_name, class_name: body.class }
+                           { function_name: func_name, class_name: body.class }
     end
     unless body.body.is_a?(Puppet::Pops::Model::EppExpression)
-      #TRANSLATORS 'EppExpression' is a class name and should not be translated
+      # TRANSLATORS 'EppExpression' is a class name and should not be translated
       raise ArgumentError, _("%{function_name}(): the parser did not produce an EppExpression, got '%{class_name}'") %
-          { function_name: func_name, class_name: body.body.class }
+                           { function_name: func_name, class_name: body.body.class }
     end
     unless parse_result.definitions.empty?
-      #TRANSLATORS 'EPP' refers to 'Embedded Puppet (EPP) template'
+      # TRANSLATORS 'EPP' refers to 'Embedded Puppet (EPP) template'
       raise ArgumentError, _("%{function_name}(): The EPP template contains illegal expressions (definitions)") %
-          { function_name: func_name }
+                           { function_name: func_name }
     end
 
     parameters_specified = body.body.parameters_specified
@@ -81,11 +82,11 @@ class Puppet::Pops::Evaluator::EppEvaluator
     end
 
     # filter out all qualified names and set them in qualified_variables
-    # only pass unqualified (filtered) variable names to the the template
+    # only pass unqualified (filtered) variable names to the template
     filtered_args = {}
     template_args.each_pair do |k, v|
       if k =~ /::/
-        k = k[2..-1] if k.start_with?('::')
+        k = k[2..] if k.start_with?('::')
         scope[k] = v
       else
         filtered_args[k] = v
@@ -109,9 +110,9 @@ class Puppet::Pops::Evaluator::EppEvaluator
       [{}, false]
     else
       unless template_args.is_a?(Hash)
-        #TRANSLATORS 'template_args' is a variable name and should not be translated
+        # TRANSLATORS 'template_args' is a variable name and should not be translated
         raise ArgumentError, _("%{function_name}(): the template_args must be a Hash, got a %{class_name}") %
-            { function_name: func_name, class_name: template_args.class }
+                             { function_name: func_name, class_name: template_args.class }
       end
       [template_args, true]
     end