openvox 7.37.1

data/lib/puppet/pops/visitor.rb

@@ -0,0 +1,122 @@
+module Puppet::Pops
+# A Visitor performs delegation to a given receiver based on the configuration of the Visitor.
+# A new visitor is created with a given receiver, a method prefix, min, and max argument counts.
+# e.g.
+#   visitor = Visitor.new(self, "visit_from", 1, 1)
+# will make the visitor call "self.visit_from_CLASS(x)" where CLASS is resolved to the given
+# objects class, or one of is ancestors, the first class for which there is an implementation of
+# a method will be selected.
+#
+# Raises RuntimeError if there are too few or too many arguments, or if the receiver is not
+# configured to handle a given visiting object.
+#
+class Visitor
+  attr_reader :receiver, :message, :min_args, :max_args, :cache
+  def initialize(receiver, message, min_args=0, max_args=nil)
+    raise ArgumentError.new("min_args must be >= 0") if min_args < 0
+    raise ArgumentError.new("max_args must be >= min_args or nil") if max_args && max_args < min_args
+
+    @receiver = receiver
+    @message = message
+    @min_args = min_args
+    @max_args = max_args
+    @cache = Hash.new
+  end
+
+  # Visit the configured receiver
+  def visit(thing, *args)
+    visit_this(@receiver, thing, args)
+  end
+
+  NO_ARGS = EMPTY_ARRAY
+
+  # Visit an explicit receiver
+  def visit_this(receiver, thing, args)
+    raise "Visitor Error: Too few arguments passed. min = #{@min_args}" unless args.length >= @min_args
+    if @max_args
+      raise "Visitor Error: Too many arguments passed. max = #{@max_args}" unless args.length <= @max_args
+    end
+    method_name = @cache[thing.class]
+    if method_name
+      return receiver.send(method_name, thing, *args)
+    else
+      thing.class.ancestors().each do |ancestor|
+        name = ancestor.name
+        next if name.nil?
+        method_name = :"#{@message}_#{name.split(DOUBLE_COLON).last}"
+        next unless receiver.respond_to?(method_name, true)
+        @cache[thing.class] = method_name
+        return receiver.send(method_name, thing, *args)
+      end
+    end
+    raise "Visitor Error: the configured receiver (#{receiver.class}) can't handle instance of: #{thing.class}"
+  end
+
+  # Visit an explicit receiver
+  def visit_this_class(receiver, clazz, args)
+    raise "Visitor Error: Too few arguments passed. min = #{@min_args}" unless args.length >= @min_args
+    if @max_args
+      raise "Visitor Error: Too many arguments passed. max = #{@max_args}" unless args.length <= @max_args
+    end
+    method_name = @cache[clazz]
+    if method_name
+      return receiver.send(method_name, clazz, *args)
+    else
+      clazz.ancestors().each do |ancestor|
+        name = ancestor.name
+        next if name.nil?
+        method_name = :"#{@message}_#{name.split(DOUBLE_COLON).last}"
+        next unless receiver.respond_to?(method_name, true)
+        @cache[clazz] = method_name
+        return receiver.send(method_name, clazz, *args)
+      end
+    end
+    raise "Visitor Error: the configured receiver (#{receiver.class}) can't handle instance of: #{clazz}"
+  end
+
+  # Visit an explicit receiver with 0 args
+  # (This is ~30% faster than calling the general method)
+  #
+  def visit_this_0(receiver, thing)
+    method_name = @cache[thing.class]
+    if method_name
+      return receiver.send(method_name, thing)
+    end
+    visit_this(receiver, thing, NO_ARGS)
+  end
+
+  # Visit an explicit receiver with 1 args
+  # (This is ~30% faster than calling the general method)
+  #
+  def visit_this_1(receiver, thing, arg)
+    method_name = @cache[thing.class]
+    if method_name
+      return receiver.send(method_name, thing, arg)
+    end
+    visit_this(receiver, thing, [arg])
+  end
+
+  # Visit an explicit receiver with 2 args
+  # (This is ~30% faster than calling the general method)
+  #
+  def visit_this_2(receiver, thing, arg1, arg2)
+    method_name = @cache[thing.class]
+    if method_name
+      return receiver.send(method_name, thing, arg1, arg2)
+    end
+    visit_this(receiver, thing, [arg1, arg2])
+  end
+
+  # Visit an explicit receiver with 3 args
+  # (This is ~30% faster than calling the general method)
+  #
+  def visit_this_3(receiver, thing, arg1, arg2, arg3)
+    method_name = @cache[thing.class]
+    if method_name
+      return receiver.send(method_name, thing, arg1, arg2, arg3)
+    end
+    visit_this(receiver, thing, [arg1, arg2, arg3])
+  end
+
+end
+end

data/lib/puppet/pops.rb

@@ -0,0 +1,121 @@
+module Puppet
+  # The Pops language system. This includes the parser, evaluator, AST model, and
+  # Binder.
+  #
+  # @todo Explain how a user should use this to parse and evaluate the puppet
+  #   language.
+  #
+  # @note Warning: Pops is still considered experimental, as such the API may
+  #   change at any time.
+  #
+  # @api public
+  module Pops
+    EMPTY_HASH = {}.freeze
+    EMPTY_ARRAY = [].freeze
+    EMPTY_STRING = ''.freeze
+
+    MAX_INTEGER =  0x7fffffffffffffff
+    MIN_INTEGER = -0x8000000000000000
+
+    DOUBLE_COLON = '::'.freeze
+    USCORE = '_'.freeze
+
+    require 'semantic_puppet'
+
+    require_relative 'pops/patterns'
+    require_relative 'pops/utils'
+    require_relative 'pops/puppet_stack'
+
+    require_relative 'pops/adaptable'
+    require_relative 'pops/adapters'
+
+    require_relative 'pops/visitable'
+    require_relative 'pops/visitor'
+
+    require_relative 'pops/issues'
+    require_relative 'pops/semantic_error'
+    require_relative 'pops/label_provider'
+    require_relative 'pops/validation'
+    require_relative 'pops/issue_reporter'
+
+    require_relative 'pops/time/timespan'
+    require_relative 'pops/time/timestamp'
+
+    # (the Types module initializes itself)
+    require_relative 'pops/types/types'
+    require_relative 'pops/types/string_converter'
+    require_relative 'pops/lookup'
+
+    require_relative 'pops/merge_strategy'
+
+    module Model
+      require_relative 'pops/model/ast'
+      require_relative 'pops/model/tree_dumper'
+      require_relative 'pops/model/ast_transformer'
+      require_relative 'pops/model/factory'
+      require_relative 'pops/model/model_tree_dumper'
+      require_relative 'pops/model/model_label_provider'
+    end
+
+    module Resource
+      require_relative 'pops/resource/resource_type_impl'
+    end
+    module Evaluator
+      require_relative 'pops/evaluator/literal_evaluator'
+      require_relative 'pops/evaluator/callable_signature'
+      require_relative 'pops/evaluator/runtime3_converter'
+      require_relative 'pops/evaluator/runtime3_resource_support'
+      require_relative 'pops/evaluator/runtime3_support'
+      require_relative 'pops/evaluator/evaluator_impl'
+      require_relative 'pops/evaluator/epp_evaluator'
+      require_relative 'pops/evaluator/collector_transformer'
+      require_relative 'pops/evaluator/puppet_proc'
+      require_relative 'pops/evaluator/deferred_resolver'
+      module Collectors
+        require_relative 'pops/evaluator/collectors/abstract_collector'
+        require_relative 'pops/evaluator/collectors/fixed_set_collector'
+        require_relative 'pops/evaluator/collectors/catalog_collector'
+        require_relative 'pops/evaluator/collectors/exported_collector'
+      end
+    end
+
+    module Parser
+      require_relative 'pops/parser/eparser'
+      require_relative 'pops/parser/parser_support'
+      require_relative 'pops/parser/locator'
+      require_relative 'pops/parser/locatable'
+      require_relative 'pops/parser/lexer2'
+      require_relative 'pops/parser/evaluating_parser'
+      require_relative 'pops/parser/epp_parser'
+      require_relative 'pops/parser/code_merger'
+    end
+
+    module Validation
+      require_relative 'pops/validation/checker4_0'
+      require_relative 'pops/validation/validator_factory_4_0'
+    end
+
+    # Subsystem for puppet functions defined in ruby.
+    #
+    # @api public
+    module Functions
+      require_relative 'pops/functions/function'
+      require_relative 'pops/functions/dispatch'
+      require_relative 'pops/functions/dispatcher'
+    end
+
+    module Migration
+      require_relative 'pops/migration/migration_checker'
+    end
+
+    module Serialization
+      require_relative 'pops/serialization'
+    end
+  end
+
+  require_relative '../puppet/parser/ast/pops_bridge'
+  require_relative '../puppet/functions'
+  require_relative '../puppet/datatypes'
+
+  Puppet::Pops::Model.register_pcore_types
+end

data/lib/puppet/property/boolean.rb

@@ -0,0 +1,7 @@
+require_relative '../../puppet/coercion'
+
+class Puppet::Property::Boolean < Puppet::Property
+  def unsafe_munge(value)
+    Puppet::Coercion.boolean(value)
+  end
+end

data/lib/puppet/property/ensure.rb

@@ -0,0 +1,106 @@
+require_relative '../../puppet/property'
+
+# This property is automatically added to any {Puppet::Type} that responds
+# to the methods 'exists?', 'create', and 'destroy'.
+#
+# Ensure defaults to having the wanted _(should)_ value `:present`.
+#
+# @api public
+#
+class Puppet::Property::Ensure < Puppet::Property
+  @name = :ensure
+
+  def self.defaultvalues
+    newvalue(:present) do
+      if @resource.provider and @resource.provider.respond_to?(:create)
+        @resource.provider.create
+      else
+        @resource.create
+      end
+      nil # return nil so the event is autogenerated
+    end
+
+    newvalue(:absent) do
+      if @resource.provider and @resource.provider.respond_to?(:destroy)
+        @resource.provider.destroy
+      else
+        @resource.destroy
+      end
+      nil # return nil so the event is autogenerated
+    end
+
+    defaultto do
+      if @resource.managed?
+        :present
+      else
+        nil
+      end
+    end
+
+    # This doc will probably get overridden
+    @doc ||= "The basic property that the resource should be in."
+  end
+
+  def self.inherited(sub)
+    # Add in the two properties that everyone will have.
+    sub.class_eval do
+    end
+  end
+
+  def change_to_s(currentvalue, newvalue)
+    begin
+      if currentvalue == :absent || currentvalue.nil?
+        return _("created")
+      elsif newvalue == :absent
+        return _("removed")
+      else
+        return _('%{name} changed %{is} to %{should}') % { name: name, is: is_to_s(currentvalue), should: should_to_s(newvalue) }
+      end
+    rescue Puppet::Error
+      raise
+    rescue => detail
+      raise Puppet::DevError, _("Could not convert change %{name} to string: %{detail}") % { name: self.name, detail: detail }, detail.backtrace
+    end
+  end
+
+  # Retrieves the _is_ value for the ensure property.
+  # The existence of the resource is checked by first consulting the provider (if it responds to
+  # `:exists`), and secondly the resource. A a value of `:present` or `:absent` is returned
+  # depending on if the managed entity exists or not.
+  #
+  # @return [Symbol] a value of `:present` or `:absent` depending on if it exists or not
+  # @raise [Puppet::DevError] if neither the provider nor the resource responds to `:exists`
+  #
+  def retrieve
+    # XXX This is a problem -- whether the object exists or not often
+    # depends on the results of other properties, yet we're the first property
+    # to get checked, which means that those other properties do not have
+    # @is values set.  This seems to be the source of quite a few bugs,
+    # although they're mostly logging bugs, not functional ones.
+    prov = @resource.provider
+    if prov && prov.respond_to?(:exists?)
+      result = prov.exists?
+    elsif @resource.respond_to?(:exists?)
+      result = @resource.exists?
+    else
+      raise Puppet::DevError, _("No ability to determine if %{name} exists") % { name: @resource.class.name }
+    end
+    if result
+      return :present
+    else
+      return :absent
+    end
+  end
+
+  # If they're talking about the thing at all, they generally want to
+  # say it should exist.
+  #defaultto :present
+  defaultto do
+    if @resource.managed?
+      :present
+    else
+      nil
+    end
+  end
+end
+

data/lib/puppet/property/keyvalue.rb

@@ -0,0 +1,158 @@
+require_relative '../../puppet/property'
+
+module Puppet
+  class Property
+    # This subclass of {Puppet::Property} manages string key value pairs.
+    # In order to use this property:
+    #
+    # * the _should_ value must be an array of key-value pairs separated by the 'separator'
+    # * the retrieve method should return a hash with the keys as symbols
+    # @note **IMPORTANT**: In order for this property to work there must also be a 'membership' parameter
+    #   The class that inherits from property should override that method with the symbol for the membership
+    # @todo The node with an important message is not very clear.
+    #
+    class KeyValue < Property
+      class << self
+        # This is a class-level variable that child properties can override
+        # if they wish.
+        attr_accessor :log_only_changed_or_new_keys
+      end
+
+      self.log_only_changed_or_new_keys = false
+
+      def hash_to_key_value_s(hash)
+        if self.class.log_only_changed_or_new_keys
+          hash = hash.select { |k, _| @changed_or_new_keys.include?(k) }
+        end
+
+        hash.map { |*pair| pair.join(separator) }.join(delimiter)
+      end
+
+      def should_to_s(should_value)
+        hash_to_key_value_s(should_value)
+      end
+
+      def is_to_s(current_value)
+        hash_to_key_value_s(current_value)
+      end
+
+      def membership
+        :key_value_membership
+      end
+
+      def inclusive?
+        @resource[membership] == :inclusive
+      end
+
+      def hashify_should
+        # Puppet casts all should values to arrays. Thus, if the user
+        # passed in a hash for our property's should value, the should_value
+        # parameter will be a single element array so we just extract our value
+        # directly.
+        if ! @should.empty? && @should.first.is_a?(Hash)
+          return @should.first
+        end
+
+        # Here, should is an array of key/value pairs.
+        @should.inject({}) do |hash, key_value|
+          tmp = key_value.split(separator)
+          hash[tmp[0].strip.intern] = tmp[1]
+          hash
+        end
+      end
+
+      def process_current_hash(current)
+        return {} if current == :absent
+
+        #inclusive means we are managing everything so if it isn't in should, its gone
+        current.each_key { |key| current[key] = nil } if inclusive?
+        current
+      end
+
+      def should
+        return nil unless @should
+
+        members = hashify_should
+        current = process_current_hash(retrieve)
+
+        #shared keys will get overwritten by members
+        should_value = current.merge(members)
+
+        # Figure out the keys that will actually change in our Puppet run.
+        # This lets us reduce the verbosity of Puppet's logging for instances
+        # of this class when we want to.
+        #
+        # NOTE: We use ||= here because we only need to compute the
+        # changed_or_new_keys once (since this property will only be synced once).
+        #
+        @changed_or_new_keys ||= should_value.keys.select do |key|
+          ! current.key?(key) || current[key] != should_value[key]
+        end
+
+        should_value
+      end
+
+      # @return [String] Returns a default separator of "="
+      def separator
+        "="
+      end
+
+      # @return [String] Returns a default delimiter of ";"
+      def delimiter
+        ";"
+      end
+
+      # Retrieves the key-hash from the provider by invoking its method named the same as this property.
+      # @return [Hash] the hash from the provider, or `:absent`
+      #
+      def retrieve
+        #ok, some 'convention' if the keyvalue property is named properties, provider should implement a properties method
+        key_hash = provider.send(name) if provider
+        if key_hash && key_hash != :absent
+          return key_hash
+        else
+          return :absent
+        end
+      end
+
+      # Returns true if there is no _is_ value, else returns if _is_ is equal to _should_ using == as comparison.
+      # @return [Boolean] whether the property is in sync or not.
+      def insync?(is)
+        return true unless is
+
+        (is == self.should)
+      end
+
+      # We only accept an array of key/value pairs (strings), a single
+      # key/value pair (string) or a Hash as valid values for our property.
+      # Note that for an array property value, the 'value' passed into the
+      # block corresponds to the array element.
+      validate do |value|
+        unless value.is_a?(String) || value.is_a?(Hash)
+          raise ArgumentError, _("The %{name} property must be specified as a hash or an array of key/value pairs (strings)!") % { name: name }
+        end
+
+        next if value.is_a?(Hash)
+
+        unless value.include?("#{separator}")
+          raise ArgumentError, _("Key/value pairs must be separated by '%{separator}'") % {separator: separator}
+        end
+      end
+
+      # The validate step ensures that our passed-in value is
+      # either a String or a Hash. If our value's a string,
+      # then nothing else needs to be done. Otherwise, we need
+      # to stringify the hash's keys and values to match our
+      # internal representation of the property's value.
+      munge do |value|
+        next value if value.is_a?(String)
+
+        munged_value = value.to_a.map! do |hash_key, hash_value|
+          [hash_key.to_s.strip.to_sym, hash_value.to_s]
+        end
+
+        Hash[munged_value]
+      end
+    end
+  end
+end

data/lib/puppet/property/list.rb

@@ -0,0 +1,70 @@
+require_relative '../../puppet/property'
+
+module Puppet
+  class Property
+    # This subclass of {Puppet::Property} manages an unordered list of values.
+    # For an ordered list see {Puppet::Property::OrderedList}.
+    #
+    class List < Property
+
+      def is_to_s(currentvalue)
+        currentvalue == :absent ? super(currentvalue) : currentvalue.join(delimiter)
+      end
+
+      def membership
+        :membership
+      end
+
+      def add_should_with_current(should, current)
+        should += current if current.is_a?(Array)
+        should.uniq
+      end
+
+      def inclusive?
+        @resource[membership] == :inclusive
+      end
+
+      #dearrayify was motivated because to simplify the implementation of the OrderedList property
+      def dearrayify(array)
+        array.sort.join(delimiter)
+      end
+
+      def should
+        return nil unless @should
+
+        members = @should
+        #inclusive means we are managing everything so if it isn't in should, its gone
+        members = add_should_with_current(members, retrieve) if ! inclusive?
+
+        dearrayify(members)
+      end
+
+      def delimiter
+        ","
+      end
+
+      def retrieve
+        #ok, some 'convention' if the list property is named groups, provider should implement a groups method
+        tmp = provider.send(name) if provider
+        if tmp && tmp != :absent
+          return tmp.instance_of?(Array) ? tmp : tmp.split(delimiter)
+        else
+          return :absent
+        end
+      end
+
+      def prepare_is_for_comparison(is)
+        if is == :absent
+          is = []
+        end
+        dearrayify(is)
+      end
+
+      def insync?(is)
+        return true unless is
+
+        (prepare_is_for_comparison(is) == self.should)
+      end
+    end
+  end
+end

data/lib/puppet/property/ordered_list.rb

@@ -0,0 +1,29 @@
+require_relative '../../puppet/property/list'
+
+module Puppet
+  class Property
+    # This subclass of {Puppet::Property} manages an ordered list of values.
+    # The maintained order is the order defined by the 'current' set of values (i.e. the
+    # original order is not disrupted). Any additions are added after the current values
+    # in their given order).
+    #
+    # For an unordered list see {Puppet::Property::List}.
+    #
+    class OrderedList < List
+
+      def add_should_with_current(should, current)
+        if current.is_a?(Array)
+          #tricky trick
+          #Preserve all the current items in the list
+          #but move them to the back of the line
+          should = should + (current - should)
+        end
+        should
+      end
+
+      def dearrayify(array)
+        array.join(delimiter)
+      end
+    end
+  end
+end