openvox 7.37.1

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

@@ -0,0 +1,107 @@
+# CallableSignature
+# ===
+# A CallableSignature describes how something callable expects to be called.
+# Different implementation of this class are used for different types of callables.
+#
+# @api public
+#
+class Puppet::Pops::Evaluator::CallableSignature
+
+  # Returns the names of the parameters as an array of strings. This does not include the name
+  # of an optional block parameter.
+  #
+  # All implementations are not required to supply names for parameters. They may be used if present,
+  # to provide user feedback in errors etc. but they are not authoritative about the number of
+  # required arguments, optional arguments, etc.
+  #
+  # A derived class must implement this method.
+  #
+  # @return [Array<String>] - an array of names (that may be empty if names are unavailable)
+  #
+  # @api public
+  #
+  def parameter_names
+    raise NotImplementedError.new
+  end
+
+  # Returns a PCallableType with the type information, required and optional count, and type information about
+  # an optional block.
+  #
+  # A derived class must implement this method.
+  #
+  # @return [Puppet::Pops::Types::PCallableType]
+  # @api public
+  #
+  def type
+    raise NotImplementedError.new
+  end
+
+  # Returns the expected type for an optional block. The type may be nil, which means that the callable does
+  # not accept a block. If a type is returned it is one of Callable, Optional[Callable], Variant[Callable,...],
+  # or Optional[Variant[Callable, ...]]. The Variant type is used when multiple signatures are acceptable.
+  # The Optional type is used when the block is optional.
+  #
+  # @return [Puppet::Pops::Types::PAnyType, nil] the expected type of a block given as the last parameter in a call.
+  #
+  # @api public
+  #
+  def block_type
+    type.block_type
+  end
+
+  # Returns the name of the block parameter if the callable accepts a block.
+  # @return [String] the name of the block parameter
+  # A derived class must implement this method.
+  # @api public
+  #
+  def block_name
+    raise NotImplementedError.new
+  end
+
+  # Returns a range indicating the optionality of a block. One of [0,0] (does not accept block), [0,1] (optional
+  # block), and [1,1] (block required)
+  #
+  # @return [Array(Integer, Integer)] the range of the block parameter
+  #
+  def block_range
+    type.block_range
+  end
+
+  # Returns the range of required/optional argument values as an array of [min, max], where an infinite
+  # end is given as Float::INFINITY. To test against infinity, use the infinity? method.
+  #
+  # @return [Array[Integer, Numeric]] - an Array with [min, max]
+  #
+  # @api public
+  #
+  def args_range
+    type.size_range
+  end
+
+  # Returns true if the last parameter captures the rest of the arguments, with a possible cap, as indicated
+  # by the `args_range` method.
+  # A derived class must implement this method.
+  #
+  # @return [Boolean] true if last parameter captures the rest of the given arguments (up to a possible cap)
+  # @api public
+  #
+  def last_captures_rest?
+    raise NotImplementedError.new
+  end
+
+  # Returns true if the given x is infinity
+  # @return [Boolean] true, if given value represents infinity
+  #
+  # @api public
+  #
+  def infinity?(x)
+    x == Float::INFINITY
+  end
+
+  # @return [Boolean] true if this signature represents an argument mismatch, false otherwise
+  #
+  # @api private
+  def argument_mismatch_handler?
+    false
+  end
+end

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

@@ -0,0 +1,375 @@
+module Puppet::Pops
+module Evaluator
+  class Jumper < Exception
+    attr_reader :value
+    attr_reader :file
+    attr_reader :line
+    def initialize(value, file, line)
+      @value = value
+      @file = file
+      @line = line
+    end
+  end
+
+  class Next < Jumper
+    def initialize(value, file, line)
+      super
+    end
+  end
+
+  class Return < Jumper
+    def initialize(value, file, line)
+      super
+    end
+  end
+
+  class PuppetStopIteration < StopIteration
+    attr_reader :file
+    attr_reader :line
+    attr_reader :pos
+
+    def initialize(file, line, pos = nil)
+      @file = file
+      @line = line
+      @pos = pos
+    end
+
+    def message
+      "break() from context where this is illegal"
+    end
+  end
+
+# A Closure represents logic bound to a particular scope.
+# As long as the runtime (basically the scope implementation) has the behavior of Puppet 3x it is not
+# safe to return and later use this closure.
+#
+# The 3x scope is essentially a named scope with an additional internal local/ephemeral nested scope state.
+# In 3x there is no way to directly refer to the nested scopes, instead, the named scope must be in a particular
+# state. Specifically, closures that require a local/ephemeral scope to exist at a later point will fail.
+# It is safe to call a closure (even with 3x scope) from the very same place it was defined, but not
+# returning it and expecting the closure to reference the scope's state at the point it was created.
+#
+# Note that this class is a CallableSignature, and the methods defined there should be used
+# as the API for obtaining information in a callable-implementation agnostic way.
+#
+class Closure < CallableSignature
+  attr_reader :evaluator
+  attr_reader :model
+  attr_reader :enclosing_scope
+
+  def initialize(evaluator, model)
+    @evaluator = evaluator
+    @model = model
+  end
+
+  # Evaluates a closure in its enclosing scope after having matched given arguments with parameters (from left to right)
+  # @api public
+  def call(*args)
+    call_with_scope(enclosing_scope, args)
+  end
+
+  # This method makes a Closure compatible with a Dispatch. This is used when the closure is wrapped in a Function
+  # and the function is called. (Saves an extra Dispatch that just delegates to a Closure and avoids having two
+  # checks of the argument type/arity validity).
+  # @api private
+  def invoke(instance, calling_scope, args, &block)
+    enclosing_scope.with_global_scope do |global_scope|
+      call_with_scope(global_scope, args, &block)
+    end
+  end
+
+  def call_by_name_with_scope(scope, args_hash, enforce_parameters)
+    call_by_name_internal(scope, args_hash, enforce_parameters)
+  end
+
+  def call_by_name(args_hash, enforce_parameters)
+    call_by_name_internal(enclosing_scope, args_hash, enforce_parameters)
+  end
+
+  # Call closure with argument assignment by name
+  def call_by_name_internal(closure_scope, args_hash, enforce_parameters)
+    if enforce_parameters
+      # Push a temporary parameter scope used while resolving the parameter defaults
+      closure_scope.with_parameter_scope(closure_name, parameter_names) do |param_scope|
+        # Assign all non-nil values, even those that represent non-existent parameters.
+        args_hash.each { |k, v| param_scope[k] = v unless v.nil? }
+        parameters.each do |p|
+          name = p.name
+          arg = args_hash[name]
+          if arg.nil?
+            # Arg either wasn't given, or it was undef
+            if p.value.nil?
+              # No default. Assign nil if the args_hash included it
+              param_scope[name] = nil if args_hash.include?(name)
+            else
+              param_scope[name] = param_scope.evaluate(name, p.value, closure_scope, @evaluator)
+            end
+          end
+        end
+        args_hash = param_scope.to_hash
+      end
+      Types::TypeMismatchDescriber.validate_parameters(closure_name, params_struct, args_hash)
+      result = catch(:next) do
+        @evaluator.evaluate_block_with_bindings(closure_scope, args_hash, @model.body)
+      end
+      Types::TypeAsserter.assert_instance_of(nil, return_type, result) do
+        "value returned from #{closure_name}"
+      end
+    else
+      @evaluator.evaluate_block_with_bindings(closure_scope, args_hash, @model.body)
+    end
+  end
+  private :call_by_name_internal
+
+  def parameters
+    @model.parameters
+  end
+
+  # Returns the number of parameters (required and optional)
+  # @return [Integer] the total number of accepted parameters
+  def parameter_count
+    # yes, this is duplication of code, but it saves a method call
+    @model.parameters.size
+  end
+
+  # @api public
+  def parameter_names
+    @model.parameters.collect(&:name)
+  end
+
+  def return_type
+    @return_type ||= create_return_type
+  end
+
+  # @api public
+  def type
+    @callable ||= create_callable_type
+  end
+
+  # @api public
+  def params_struct
+    @params_struct ||= create_params_struct
+  end
+
+  # @api public
+  def last_captures_rest?
+    last = @model.parameters[-1]
+    last && last.captures_rest
+  end
+
+  # @api public
+  def block_name
+    # TODO: Lambda's does not support blocks yet. This is a placeholder
+    'unsupported_block'
+  end
+
+  CLOSURE_NAME = 'lambda'.freeze
+
+  # @api public
+  def closure_name()
+    CLOSURE_NAME
+  end
+
+  class Dynamic < Closure
+    def initialize(evaluator, model, scope)
+      @enclosing_scope = scope
+      super(evaluator, model)
+    end
+
+    def enclosing_scope
+      @enclosing_scope
+    end
+
+    def call(*args)
+      # A return from an unnamed closure is treated as a return from the context evaluating
+      # calling this closure - that is, as if it was the return call itself.
+      #
+      jumper = catch(:return) do
+        return call_with_scope(enclosing_scope, args)
+      end
+      raise jumper
+    end
+  end
+
+  class Named < Closure
+    def initialize(name, evaluator, model)
+      @name = name
+      super(evaluator, model)
+    end
+
+    def closure_name
+      @name
+    end
+
+    # The assigned enclosing scope, or global scope if enclosing scope was initialized to nil
+    #
+    def enclosing_scope
+      # Named closures are typically used for puppet functions and they cannot be defined
+      # in an enclosing scope as they are cashed and reused. They need to bind to the
+      # global scope at time of use rather at time of definition.
+      # Unnamed closures are always a runtime construct, they are never bound by a loader
+      # and are thus garbage collected at end of a compilation.
+      #
+      Puppet.lookup(:global_scope) { {} }
+    end
+  end
+
+  private
+
+  def call_with_scope(scope, args)
+    variable_bindings = combine_values_with_parameters(scope, args)
+
+    final_args = parameters.reduce([]) do |tmp_args, param|
+      if param.captures_rest
+        tmp_args.concat(variable_bindings[param.name])
+      else
+        tmp_args << variable_bindings[param.name]
+      end
+    end
+
+    if type.callable_with?(final_args, block_type)
+      result = catch(:next) do
+        @evaluator.evaluate_block_with_bindings(scope, variable_bindings, @model.body)
+      end
+      Types::TypeAsserter.assert_instance_of(nil, return_type, result) do
+        "value returned from #{closure_name}"
+      end
+    else
+      tc = Types::TypeCalculator.singleton
+      args_type = tc.infer_set(final_args)
+      raise ArgumentError, Types::TypeMismatchDescriber.describe_signatures(closure_name, [self], args_type)
+    end
+  end
+
+  def combine_values_with_parameters(scope, args)
+    scope.with_parameter_scope(closure_name, parameter_names) do |param_scope|
+      parameters.each_with_index do |parameter, index|
+        param_captures     = parameter.captures_rest
+        default_expression = parameter.value
+
+        if index >= args.size
+          if default_expression
+            # not given, has default
+            value = param_scope.evaluate(parameter.name, default_expression, scope, @evaluator)
+
+            if param_captures && !value.is_a?(Array)
+              # correct non array default value
+              value = [value]
+            end
+          else
+            # not given, does not have default
+            if param_captures
+              # default for captures rest is an empty array
+              value = []
+            else
+              @evaluator.fail(Issues::MISSING_REQUIRED_PARAMETER, parameter, { :param_name => parameter.name })
+            end
+          end
+        else
+          given_argument = args[index]
+          if param_captures
+            # get excess arguments
+            value = args[(parameter_count-1)..-1]
+            # If the input was a single nil, or undef, and there is a default, use the default
+            # This supports :undef in case it was used in a 3x data structure and it is passed as an arg
+            #
+            if value.size == 1 && (given_argument.nil? || given_argument == :undef) && default_expression
+              value = param_scope.evaluate(parameter.name, default_expression, scope, @evaluator)
+              # and ensure it is an array
+              value = [value] unless value.is_a?(Array)
+            end
+          else
+            value = given_argument
+          end
+        end
+        param_scope[parameter.name] = value
+      end
+      param_scope.to_hash
+    end
+  end
+
+  def create_callable_type()
+    types = []
+    from = 0
+    to = 0
+    in_optional_parameters = false
+    closure_scope = enclosing_scope
+
+    parameters.each do |param|
+      type, param_range = create_param_type(param, closure_scope)
+
+      types << type
+
+      if param_range[0] == 0
+        in_optional_parameters = true
+      elsif param_range[0] != 0 && in_optional_parameters
+        @evaluator.fail(Issues::REQUIRED_PARAMETER_AFTER_OPTIONAL, param, { :param_name => param.name })
+      end
+
+      from += param_range[0]
+      to += param_range[1]
+    end
+    param_types = Types::PTupleType.new(types, Types::PIntegerType.new(from, to))
+    # The block_type for a Closure is always nil for now, see comment in block_name above
+    Types::PCallableType.new(param_types, nil, return_type)
+  end
+
+  def create_params_struct
+    type_factory = Types::TypeFactory
+    members = {}
+    closure_scope = enclosing_scope
+
+    parameters.each do |param|
+      arg_type, _ = create_param_type(param, closure_scope)
+      key_type = type_factory.string(param.name.to_s)
+      key_type = type_factory.optional(key_type) unless param.value.nil?
+      members[key_type] = arg_type
+    end
+    type_factory.struct(members)
+  end
+
+  def create_return_type
+    if @model.return_type
+      @evaluator.evaluate(@model.return_type, @enclosing_scope)
+    else
+      Types::PAnyType::DEFAULT
+    end
+  end
+
+  def create_param_type(param, closure_scope)
+    type = if param.type_expr
+             @evaluator.evaluate(param.type_expr, closure_scope)
+           else
+             Types::PAnyType::DEFAULT
+           end
+
+    if param.captures_rest && type.is_a?(Types::PArrayType)
+      # An array on a slurp parameter is how a size range is defined for a
+      # slurp (Array[Integer, 1, 3] *$param). However, the callable that is
+      # created can't have the array in that position or else type checking
+      # will require the parameters to be arrays, which isn't what is
+      # intended. The array type contains the intended information and needs
+      # to be unpacked.
+      param_range = type.size_range
+      type = type.element_type
+    elsif param.captures_rest && !type.is_a?(Types::PArrayType)
+      param_range = ANY_NUMBER_RANGE
+    elsif param.value
+      param_range = OPTIONAL_SINGLE_RANGE
+    else
+      param_range = REQUIRED_SINGLE_RANGE
+    end
+    [type, param_range]
+  end
+
+  # Produces information about parameters compatible with a 4x Function (which can have multiple signatures)
+  def signatures
+    [ self ]
+  end
+
+  ANY_NUMBER_RANGE = [0, Float::INFINITY]
+  OPTIONAL_SINGLE_RANGE = [0, 1]
+  REQUIRED_SINGLE_RANGE = [1, 1]
+end
+end
+end

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

@@ -0,0 +1,234 @@
+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)
+    @@evaluator        ||= EvaluatorImpl.new
+    @@compare_operator ||= CompareOperator.new()
+  end
+
+  def transform(o, scope)
+    #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'
+      fail "Classes cannot be collected"
+    end
+
+    resource_type = Runtime3ResourceSupport.find_resource_type(scope, type)
+
+    fail "Resource type #{type} doesn't exist" unless resource_type
+
+    if !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
+      }
+    end
+
+    code = query_unless_nop(o.query, scope)
+
+    case o.query
+    when Model::VirtualQuery
+      newcoll = Collectors::CatalogCollector.new(scope, resource_type, code, overrides)
+    when Model::ExportedQuery
+      match = match_unless_nop(o.query, scope)
+      newcoll = Collectors::ExportedCollector.new(scope, resource_type, match, code, overrides)
+    end
+
+    scope.compiler.add_collection(newcoll)
+
+    newcoll
+  end
+
+protected
+
+  def query(o, scope)
+    @@query_visitor.visit_this_1(self, o, scope)
+  end
+
+  def match(o, scope)
+    @@match_visitor.visit_this_1(self, o, scope)
+  end
+
+  def query_unless_nop(query, scope)
+    unless query.expr.nil? || query.expr.is_a?(Model::Nop)
+      query(query.expr, scope)
+    end
+  end
+
+  def match_unless_nop(query, scope)
+    unless query.expr.nil? || query.expr.is_a?(Model::Nop)
+      match(query.expr, scope)
+    end
+  end
+
+  def query_AndExpression(o, scope)
+    left_code = query(o.left_expr, scope)
+    right_code = query(o.right_expr, scope)
+    proc do |resource|
+      left_code.call(resource) && right_code.call(resource)
+    end
+  end
+
+  def query_OrExpression(o, scope)
+    left_code = query(o.left_expr, scope)
+    right_code = query(o.right_expr, scope)
+    proc do |resource|
+      left_code.call(resource) || right_code.call(resource)
+    end
+  end
+
+  def query_ComparisonExpression(o, scope)
+    left_code = query(o.left_expr, scope)
+    right_code = query(o.right_expr, scope)
+
+    case o.operator
+    when '=='
+      if left_code == "tag"
+        # Ensure that to_s and downcase is done once, i.e. outside the proc block and
+        # then use raw_tagged? instead of tagged?
+        if right_code.is_a?(Array)
+          tags = right_code
+        else
+          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|
+          resource.raw_tagged?(tags)
+        end
+      else
+        proc do |resource|
+          if (tmp = resource[left_code]).is_a?(Array)
+            @@compare_operator.include?(tmp, right_code, scope)
+          else
+            @@compare_operator.equals(tmp, right_code)
+          end
+        end
+      end
+    when '!='
+      proc do |resource|
+        !@@compare_operator.equals(resource[left_code], right_code)
+      end
+    end
+  end
+
+  def query_AccessExpression(o, scope)
+    pops_object = @@evaluator.evaluate(o, scope)
+
+    # Convert to Puppet 3 style objects since that is how they are represented
+    # in the catalog.
+    @@evaluator.convert(pops_object, scope, nil)
+  end
+
+  def query_VariableExpression(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_LiteralBoolean(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_LiteralString(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_ConcatenatedString(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_LiteralNumber(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_LiteralUndef(o, scope)
+    nil
+  end
+
+  def query_QualifiedName(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def query_ParenthesizedExpression(o, scope)
+   query(o.expr, scope)
+  end
+
+  def query_Object(o, scope)
+    raise ArgumentError, _("Cannot transform object of class %{klass}") % { klass: o.class }
+  end
+
+  def match_AccessExpression(o, scope)
+    pops_object = @@evaluator.evaluate(o, scope)
+
+    # Convert to Puppet 3 style objects since that is how they are represented
+    # in the catalog.
+    @@evaluator.convert(pops_object, scope, nil)
+  end
+
+  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]
+  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]
+  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]
+  end
+
+  def match_VariableExpression(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_LiteralBoolean(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_LiteralString(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_LiteralUndef(o, scope)
+    nil
+  end
+
+  def match_ConcatenatedString(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_LiteralNumber(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_QualifiedName(o, scope)
+    @@evaluator.evaluate(o, scope)
+  end
+
+  def match_ParenthesizedExpression(o, scope)
+   match(o.expr, scope)
+  end
+
+  def match_Object(o, scope)
+    raise ArgumentError, _("Cannot transform object of class %{klass}") % { klass: o.class }
+  end
+end
+end
+end