bolt 0.24.0 → 0.25.0

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

@@ -1,254 +0,0 @@
-module Puppet::Pops
-module Evaluator
-# Compares the puppet DSL way
-#
-# ==Equality
-# All string vs. numeric equalities check for numeric equality first, then string equality
-# Arrays are equal to arrays if they have the same length, and each element #equals
-# Hashes  are equal to hashes if they have the same size and keys and values #equals.
-# All other objects are equal if they are ruby #== equal
-#
-class CompareOperator
-  include Utils
-
-  # Provides access to the Puppet 3.x runtime (scope, etc.)
-  # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
-  #
-  include Runtime3Support
-
-  def initialize
-    @@equals_visitor  ||= Visitor.new(self, "equals", 1, 1)
-    @@compare_visitor ||= Visitor.new(self, "cmp", 1, 1)
-    @@match_visitor ||= Visitor.new(self, "match", 2, 2)
-    @@include_visitor ||= Visitor.new(self, "include", 2, 2)
-  end
-
-  def equals(a, b)
-    @@equals_visitor.visit_this_1(self, a, b)
-  end
-
-  # Performs a comparison of a and b, and return > 0 if a is bigger, 0 if equal, and < 0 if b is bigger.
-  # Comparison of String vs. Numeric always compares using numeric.
-  def compare(a, b)
-    @@compare_visitor.visit_this_1(self, a, b)
-  end
-
-  # Performs a match of a and b, and returns true if b matches a
-  def match(a, b, scope = nil)
-    @@match_visitor.visit_this_2(self, b, a, scope)
-  end
-
-  # Answers is b included in a
-  def include?(a, b, scope)
-    @@include_visitor.visit_this_2(self, a, b, scope)
-  end
-
-  protected
-
-  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"))
-  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)
-      a <=> b
-    elsif b.is_a?(Time::Timespan) || b.is_a?(Time::Timestamp)
-      -(b <=> a) # compare other way and invert result
-    else
-      raise ArgumentError.new(_("A Numeric is not comparable to non Numeric"))
-    end
-  end
-
-  def equals_Numeric(a, b)
-    if b.is_a?(Numeric)
-      a == b
-    else
-      false
-    end
-  end
-
-  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)) }
-    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)}
-    true
-  end
-
-  def cmp_Symbol(a, b)
-    if b.is_a?(Symbol)
-      a <=> b
-    else
-      raise ArgumentError.new(_("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)
-    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)
-    a <=> b
-  end
-
-  def cmp_Version(a, b)
-    raise ArgumentError.new(_('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'))
-  end
-
-
-  def equals_Object(a, b)
-    a == b
-  end
-
-  def equals_NilClass(a, b)
-    # :undef supported in case it is passed from a 3x data structure
-    b.nil? || b == :undef
-  end
-
-  def equals_Symbol(a, b)
-    # :undef supported in case it is passed from a 3x data structure
-    a == b || a == :undef && b.nil?
-  end
-
-  def include_Object(a, b, scope)
-    false
-  end
-
-  def include_String(a, b, scope)
-    case b
-    when String
-      # substring search downcased
-      a.downcase.include?(b.downcase)
-    when Regexp
-      matched = a.match(b)           # nil, or MatchData
-      set_match_data(matched, scope) # creates ephemeral
-      !!matched                      # match (convert to boolean)
-    when Numeric
-      # convert string to number, true if ==
-      equals(a, b)
-    else
-      false
-    end
-  end
-
-  def include_Binary(a, b, scope)
-    case b
-    when Puppet::Pops::Types::PBinaryType::Binary
-      a.binary_buffer.include?(b.binary_buffer)
-    when String
-      a.binary_buffer.include?(b)
-    when Numeric
-      a.binary_buffer.bytes.include?(b)
-    else
-      false
-    end
-  end
-
-  def include_Array(a, b, scope)
-    case b
-    when Regexp
-      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
-    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
-    else
-      a.each {|element| return true if equals(element, b) }
-      return false
-    end
-  end
-
-  def include_Hash(a, b, scope)
-    include?(a.keys, b, scope)
-  end
-
-  def include_VersionRange(a, b, scope)
-    Types::PSemVerRangeType.include?(a, b)
-  end
-
-  # Matches in general by using == operator
-  def match_Object(pattern, a, scope)
-    equals(a, pattern)
-  end
-
-  # 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
-  end
-
-  # Matches against semvers and strings
-  def match_Version(version, left, scope)
-    if left.is_a?(SemanticPuppet::Version)
-      version == left
-    elsif left.is_a? String
-      begin
-        version == SemanticPuppet::Version.parse(left)
-      rescue ArgumentError
-        false
-      end
-    else
-      false
-    end
-  end
-
-  # Matches against semvers and strings
-  def match_VersionRange(range, left, scope)
-    Types::PSemVerRangeType.include?(range, left)
-  end
-
-  def match_PAnyType(any_type, left, scope)
-    # right is a type and left is not - check if left is an instance of the given type
-    # (The reverse is not terribly meaningful - computing which of the case options that first produces
-    # an instance of a given type).
-    #
-    any_type.instance?(left)
-  end
-
-  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) }
-  end
-
-  def match_Hash(hash, left, scope)
-    return false unless left.is_a?(Hash)
-    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
-end
-end

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

@@ -1,130 +0,0 @@
-require 'puppet/parser/script_compiler'
-
-module Puppet::Pops
-module Evaluator
-
-# Utility class to help resolve instances of Puppet::Pops::Types::PDeferredType::Deferred
-#
-class DeferredResolver
-  DOLLAR = '$'.freeze
-  DIG    = 'dig'.freeze
-
-  # Resolves and replaces all Deferred values in a catalog's resource attributes
-  # found as direct values or nested inside Array, Hash or Sensitive values.
-  # Deferred values inside of custom Object instances are not resolved as this
-  # is expected to be done by such objects.
-  #
-  # @param facts [Puppet::Node::Facts] the facts object for the node
-  # @param catalog [Puppet::Resource::Catalog] the catalog where all deferred values should be replaced
-  # @return [nil] does not return anything - the catalog is modified as a side effect
-  #
-  def self.resolve_and_replace(facts, catalog)
-    compiler = Puppet::Parser::ScriptCompiler.new(catalog.environment_instance, catalog.name, true)
-    resolver = new(compiler)
-    resolver.set_facts_variable(facts)
-    # TODO:
-    #    # When scripting the trusted data are always local, but set them anyway
-    #    @scope.set_trusted(node.trusted_data)
-    #
-    #    # Server facts are always about the local node's version etc.
-    #    @scope.set_server_facts(node.server_facts)
-
-    resolver.resolve_futures(catalog)
-    nil
-  end
-
-  # Resolves a value such that a direct Deferred, or any nested Deferred values
-  # are resolved and used instead of the deferred value.
-  # A direct Deferred value, or nested deferred values inside of Array, Hash or
-  # Sensitive values are resolved and replaced inside of freshly created
-  # containers.
-  #
-  # The resolution takes place in the topscope of the given compiler.
-  # Variable values are supposed to already have been set.
-  #
-  # @param value [Object] the (possibly nested) value to resolve
-  # @param compiler [Puppet::Parser::ScriptCompiler, Puppet::Parser::Compiler] the compiler in effect
-  # @return [Object] the resolved value (a new Array, Hash, or Sensitive if needed), with all deferred values resolved
-  #
-  def self.resolve(value, compiler)
-    resolver = new(compiler)
-    resolver.resolve(value)
-  end
-
-  def initialize(compiler)
-    @compiler = compiler
-    # Always resolve in top scope
-    @scope = @compiler.topscope
-    @deferred_class = Puppet::Pops::Types::TypeFactory.deferred.implementation_class
-  end
-
-  # @param facts [Puppet::Node::Facts] the facts to set in $facts in the compiler's topscope
-  #
-  def set_facts_variable(facts)
-    @scope.set_facts(facts.nil? ? {} : facts.values)
-  end
-
-  def resolve_futures(catalog)
-    catalog.resources.each do |r|
-      overrides = {}
-      r.parameters.each_pair do |k, v|
-        resolved = resolve(v)
-        # If the value is instance of Sensitive - assign the unwrapped value
-        # and mark it as sensitive if not already marked
-        #
-        if resolved.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
-          resolved = resolved.unwrap
-          unless r.sensitive_parameters.include?(k.to_sym)
-            r.sensitive_parameters = (r.sensitive_parameters + [k.to_sym]).freeze
-          end
-        end
-        overrides[ k ] = resolved
-      end
-      r.parameters.merge!(overrides) unless overrides.empty?
-    end
-  end
-
-  def resolve(x)
-    if x.class == @deferred_class
-      resolve_future(x)
-    elsif x.is_a?(Array)
-      x.map {|v| resolve(v) }
-    elsif x.is_a?(Hash)
-      result = {}
-      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
-      Puppet::Pops::Types::PSensitiveType::Sensitive.new(resolve(x.unwrap))
-    elsif x.is_a?(Puppet::Pops::Types::PBinaryType::Binary)
-      # use the ASCII-8BIT string that it wraps
-      x.binary_buffer
-    else
-      x
-    end
-  end
-
-  def resolve_future(f)
-    # If any of the arguments to a future is a future it needs to be resolved first
-    func_name = f.name
-    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]
-      func_name = DIG
-      mapped_arguments.insert(0, @scope[var_name])
-    end
-
-    # call the function (name in deferred, or 'dig' for a variable)
-    @scope.call_function(func_name, mapped_arguments)
-  end
-
-  def map_arguments(args)
-    return [] if args.nil?
-    args.map {|v| resolve(v) }
-  end
-  private :map_arguments
-
-end
-end
-end

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

@@ -1,120 +0,0 @@
-# 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
-      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 }
-    end
-
-    # Parse and validate the source
-    parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new
-    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
-      raise ArgumentError, _("inline_epp(): Invalid EPP: %{detail}") % { detail: e.message }
-    end
-
-    # Evaluate (and check template_args)
-    evaluate(parser, 'inline_epp', scope, false, result, template_args)
-  end
-
-  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
-      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"
-      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)
-      raise Puppet::ParseError, _("Could not find template '%{file}'") % { file: file }
-    end
-
-    # Parse and validate the source
-    parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new
-    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
-      raise ArgumentError, _("epp(): Invalid EPP: %{detail}") % { detail: e.message }
-    end
-
-    # Evaluate (and check template_args)
-    evaluate(parser, 'epp', scope, true, result, template_args)
-  end
-
-  def self.evaluate(parser, func_name, scope, use_global_scope_only, parse_result, template_args)
-    template_args, template_args_set = handle_template_args(func_name, template_args)
-
-    body = parse_result.body
-    unless body.is_a?(Puppet::Pops::Model::LambdaExpression)
-      #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 }
-    end
-    unless body.body.is_a?(Puppet::Pops::Model::EppExpression)
-      #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 }
-    end
-    unless parse_result.definitions.empty?
-      #TRANSLATORS 'EPP' refers to 'Embedded Puppet (EPP) template'
-      raise ArgumentError, _("%{function_name}(): The EPP template contains illegal expressions (definitions)") %
-          { function_name: func_name }
-    end
-
-    parameters_specified = body.body.parameters_specified
-    if parameters_specified || template_args_set
-      enforce_parameters = parameters_specified
-    else
-      enforce_parameters = true
-    end
-
-    # filter out all qualified names and set them in qualified_variables
-    # only pass unqualified (filtered) variable names to the the template
-    filtered_args = {}
-    template_args.each_pair do |k, v|
-      if k =~ /::/
-        k = k[2..-1] if k.start_with?('::')
-        scope[k] = v
-      else
-        filtered_args[k] = v
-      end
-    end
-    template_args = filtered_args
-
-    # inline_epp() logic sees all local variables, epp() all global
-    if use_global_scope_only
-      scope.with_global_scope do |global_scope|
-        parser.closure(body, global_scope).call_by_name(template_args, enforce_parameters)
-      end
-    else
-      parser.closure(body, scope).call_by_name(template_args, enforce_parameters)
-    end
-  end
-  private_class_method :evaluate
-
-  def self.handle_template_args(func_name, template_args)
-    if template_args.nil?
-      [{}, false]
-    else
-      unless template_args.is_a?(Hash)
-        #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 }
-      end
-      [template_args, true]
-    end
-  end
-  private_class_method :handle_template_args
-end