openvox 8.19.0

data/lib/puppet/pops/time/timestamp.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Time
+class Timestamp < TimeData
+  DEFAULT_FORMATS_WO_TZ = ['%FT%T.%N', '%FT%T', '%F %T.%N', '%F %T', '%F']
+  DEFAULT_FORMATS = ['%FT%T.%N %Z', '%FT%T %Z', '%F %T.%N %Z', '%F %T %Z', '%F %Z'] + DEFAULT_FORMATS_WO_TZ
+
+  CURRENT_TIMEZONE = 'current'
+  KEY_TIMEZONE = 'timezone'
+
+  # Converts a timezone that strptime can parse using '%z' into '-HH:MM' or '+HH:MM'
+  # @param [String] tz the timezone to convert
+  # @return [String] the converted timezone
+  #
+  # @api private
+  def self.convert_timezone(tz)
+    if tz =~ /\A[+-]\d\d:\d\d\z/
+      tz
+    else
+      offset = utc_offset(tz) / 60
+      if offset < 0
+        offset = offset.abs
+        sprintf('-%2.2d:%2.2d', offset / 60, offset % 60)
+      else
+        sprintf('+%2.2d:%2.2d', offset / 60, offset % 60)
+      end
+    end
+  end
+
+  # Returns the zone offset from utc for the given `timezone`
+  # @param [String] timezone the timezone to get the offset for
+  # @return [Integer] the timezone offset, in seconds
+  #
+  # @api private
+  def self.utc_offset(timezone)
+    if CURRENT_TIMEZONE.casecmp(timezone) == 0
+      ::Time.now.utc_offset
+    else
+      hash = DateTime._strptime(timezone, '%z')
+      offset = hash.nil? ? nil : hash[:offset]
+      raise ArgumentError, _("Illegal timezone '%{timezone}'") % { timezone: timezone } if offset.nil?
+
+      offset
+    end
+  end
+
+  # Formats a ruby Time object using the given timezone
+  def self.format_time(format, time, timezone)
+    unless timezone.nil? || timezone.empty?
+      time = time.localtime(convert_timezone(timezone))
+    end
+    time.strftime(format)
+  end
+
+  def self.now
+    from_time(::Time.now)
+  end
+
+  def self.from_time(t)
+    new(t.tv_sec * NSECS_PER_SEC + t.tv_nsec)
+  end
+
+  def self.from_hash(args_hash)
+    parse(args_hash[KEY_STRING], args_hash[KEY_FORMAT], args_hash[KEY_TIMEZONE])
+  end
+
+  def self.parse(str, format = :default, timezone = nil)
+    has_timezone = !(timezone.nil? || timezone.empty? || timezone == :default)
+    if format.nil? || format == :default
+      format = has_timezone ? DEFAULT_FORMATS_WO_TZ : DEFAULT_FORMATS
+    end
+
+    parsed = nil
+    if format.is_a?(Array)
+      format.each do |fmt|
+        parsed = DateTime._strptime(str, fmt)
+        next if parsed.nil?
+
+        if parsed.include?(:leftover) || (has_timezone && parsed.include?(:zone))
+          parsed = nil
+          next
+        end
+        break
+      end
+      if parsed.nil?
+        raise ArgumentError, _(
+          "Unable to parse '%{str}' using any of the formats %{formats}"
+        ) % { str: str, formats: format.join(', ') }
+      end
+    else
+      parsed = DateTime._strptime(str, format)
+      if parsed.nil? || parsed.include?(:leftover)
+        raise ArgumentError, _("Unable to parse '%{str}' using format '%{format}'") % { str: str, format: format }
+      end
+
+      if has_timezone && parsed.include?(:zone)
+        raise ArgumentError, _(
+          'Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument'
+        )
+      end
+    end
+    unless has_timezone
+      timezone = parsed[:zone]
+      has_timezone = !timezone.nil?
+    end
+    fraction = parsed[:sec_fraction]
+
+    # Convert msec rational found in _strptime hash to usec
+    fraction *= 1_000_000 unless fraction.nil?
+
+    # Create the Time instance and adjust for timezone
+    parsed_time = ::Time.utc(parsed[:year], parsed[:mon], parsed[:mday], parsed[:hour], parsed[:min], parsed[:sec], fraction)
+    parsed_time -= utc_offset(timezone) if has_timezone
+
+    # Convert to Timestamp
+    from_time(parsed_time)
+  end
+
+  undef_method :-@, :+@, :div, :fdiv, :abs, :abs2, :magnitude # does not make sense on a Timestamp
+  if method_defined?(:negative?)
+    undef_method :negative?, :positive?
+  end
+  if method_defined?(:%)
+    undef_method :%, :modulo, :divmod
+  end
+
+  def +(o)
+    case o
+    when Timespan
+      Timestamp.new(@nsecs + o.nsecs)
+    when Integer, Float
+      Timestamp.new(@nsecs + (o * NSECS_PER_SEC).to_i)
+    else
+      raise ArgumentError, _("%{klass} cannot be added to a Timestamp") % { klass: a_an_uc(o) }
+    end
+  end
+
+  def -(o)
+    case o
+    when Timestamp
+      # Diff between two timestamps is a timespan
+      Timespan.new(@nsecs - o.nsecs)
+    when Timespan
+      Timestamp.new(@nsecs - o.nsecs)
+    when Integer, Float
+      # Subtract seconds
+      Timestamp.new(@nsecs - (o * NSECS_PER_SEC).to_i)
+    else
+      raise ArgumentError, _("%{klass} cannot be subtracted from a Timestamp") % { klass: a_an_uc(o) }
+    end
+  end
+
+  def format(format, timezone = nil)
+    self.class.format_time(format, to_time, timezone)
+  end
+
+  def to_s
+    format(DEFAULT_FORMATS[0])
+  end
+
+  def to_time
+    ::Time.at(to_r).utc
+  end
+end
+end
+end

data/lib/puppet/pops/types/annotatable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Types
+KEY_ANNOTATIONS = 'annotations'
+
+# Behaviour common to all Pcore annotatable classes
+#
+# @api public
+module Annotatable
+  TYPE_ANNOTATIONS = PHashType.new(PTypeType.new(PTypeReferenceType.new('Annotation')), PHashType::DEFAULT)
+
+  # @return [{PTypeType => PStructType}] the map of annotations
+  # @api public
+  def annotations
+    @annotations.nil? ? EMPTY_HASH : @annotations
+  end
+
+  # @api private
+  def init_annotatable(init_hash)
+    @annotations = init_hash[KEY_ANNOTATIONS].freeze
+  end
+
+  # @api private
+  def annotatable_accept(visitor, guard)
+    @annotations.each_key { |key| key.accept(visitor, guard) } unless @annotations.nil?
+  end
+
+  # @api private
+  def _pcore_init_hash
+    result = {}
+    result[KEY_ANNOTATIONS] = @annotations unless @annotations.nil?
+    result
+  end
+end
+end
+end

data/lib/puppet/pops/types/annotation.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Types
+  # Pcore variant of the Adaptable::Adapter. Uses a Pcore Object type instead of a Class
+  class Annotation < Adaptable::Adapter
+    include Types::PuppetObject
+
+    CLEAR = 'clear'
+
+    # Register the Annotation type. This is the type that all custom Annotations will inherit from.
+    def self.register_ptype(loader, ir)
+      @type = Pcore.create_object_type(loader, ir, self, 'Annotation', nil, EMPTY_HASH)
+    end
+
+    def self._pcore_type
+      @type
+    end
+
+    # Finds an existing annotation for the given object and returns it.
+    # If no annotation was found, and a block is given, a new annotation is created from the
+    # initializer hash that must be returned from the block.
+    # If no annotation was found and no block is given, this method returns `nil`
+    #
+    # @param o [Object] object to annotate
+    # @param block [Proc] optional, evaluated when a new annotation must be created. Should return the init hash
+    # @return [Annotation<self>] an annotation of the same class as the receiver of the call
+    #
+    def self.annotate(o)
+      adapter = get(o)
+      if adapter.nil?
+        if o.is_a?(Annotatable)
+          init_hash = o.annotations[_pcore_type]
+          init_hash = yield if init_hash.nil? && block_given?
+        elsif block_given?
+          init_hash = yield
+        end
+        adapter = associate_adapter(_pcore_type.from_hash(init_hash), o) unless init_hash.nil?
+      end
+      adapter
+    end
+
+    # Forces the creation or removal of an annotation of this type.
+    # If `init_hash` is a hash, a new annotation is created and returned
+    # If `init_hash` is `nil`, then the annotation is cleared and the previous annotation is returned.
+    #
+    # @param o [Object] object to annotate
+    # @param init_hash [Hash{String,Object},nil] the initializer for the annotation or `nil` to clear the annotation
+    # @return [Annotation<self>] an annotation of the same class as the receiver of the call
+    #
+    def self.annotate_new(o, init_hash)
+      if o.is_a?(Annotatable) && o.annotations.include?(_pcore_type)
+        # Prevent clear or redefine of annotations declared on type
+        action = init_hash == CLEAR ? 'clear' : 'redefine'
+        raise ArgumentError, "attempt to #{action} #{type_name} annotation declared on #{o.label}"
+      end
+
+      if init_hash == CLEAR
+        clear(o)
+      else
+        associate_adapter(_pcore_type.from_hash(init_hash), o)
+      end
+    end
+
+    # Uses name of type instead of name of the class (the class is likely dynamically generated and as such,
+    # has no name)
+    # @return [String] the name of the type
+    def self.type_name
+      _pcore_type.name
+    end
+  end
+end
+end

data/lib/puppet/pops/types/class_loader.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Types
+# The ClassLoader provides a Class instance given a class name or a meta-type.
+# If the class is not already loaded, it is loaded using the Puppet Autoloader.
+# This means it can load a class from a gem, or from puppet modules.
+#
+class ClassLoader
+  @autoloader = Puppet::Util::Autoload.new("ClassLoader", "")
+
+  # Returns a Class given a fully qualified class name.
+  # Lookup of class is never relative to the calling namespace.
+  # @param name [String, Array<String>, Array<Symbol>, PAnyType] A fully qualified
+  #   class name String (e.g. '::Foo::Bar', 'Foo::Bar'), a PAnyType, or a fully qualified name in Array form where each part
+  #   is either a String or a Symbol, e.g. `%w{Puppetx Puppetlabs SomeExtension}`.
+  # @return [Class, nil] the looked up class or nil if no such class is loaded
+  # @raise ArgumentError If the given argument has the wrong type
+  # @api public
+  #
+  def self.provide(name)
+    case name
+    when String
+      provide_from_string(name)
+
+    when Array
+      provide_from_name_path(name.join('::'), name)
+
+    when PAnyType, PTypeType
+      provide_from_type(name)
+
+    else
+      raise ArgumentError, "Cannot provide a class from a '#{name.class.name}'"
+    end
+  end
+
+  def self.provide_from_type(type)
+    case type
+    when PRuntimeType
+      raise ArgumentError, "Only Runtime type 'ruby' is supported, got #{type.runtime}" unless type.runtime == :ruby
+
+      provide_from_string(type.runtime_type_name)
+
+    when PBooleanType
+      # There is no other thing to load except this Enum meta type
+      RGen::MetamodelBuilder::MMBase::Boolean
+
+    when PTypeType
+      # TODO: PTypeType should have a type argument (a PAnyType) so the Class' class could be returned
+      #       (but this only matters in special circumstances when meta programming has been used).
+      Class
+
+    when POptionalType
+      # cannot make a distinction between optional and its type
+      provide_from_type(type.optional_type)
+
+    # Although not expected to be the first choice for getting a concrete class for these
+    # types, these are of value if the calling logic just has a reference to type.
+    # rubocop:disable Layout/SpaceBeforeSemicolon
+    when PArrayType    ; Array
+    when PTupleType    ; Array
+    when PHashType     ; Hash
+    when PStructType   ; Hash
+    when PRegexpType   ; Regexp
+    when PIntegerType  ; Integer
+    when PStringType   ; String
+    when PPatternType  ; String
+    when PEnumType     ; String
+    when PFloatType    ; Float
+    when PUndefType    ; NilClass
+    when PCallableType ; Proc
+    # rubocop:enable Layout/SpaceBeforeSemicolon
+    else
+      nil
+    end
+  end
+  private_class_method :provide_from_type
+
+  def self.provide_from_string(name)
+    name_path = name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
+    # always from the root, so remove an empty first segment
+    name_path.shift if name_path[0].empty?
+    provide_from_name_path(name, name_path)
+  end
+
+  def self.provide_from_name_path(name, name_path)
+    # If class is already loaded, try this first
+    result = find_class(name_path)
+
+    unless result.is_a?(Module)
+      # Attempt to load it using the auto loader
+      loaded_path = nil
+      if paths_for_name(name_path).find { |path| loaded_path = path; @autoloader.load(path, Puppet.lookup(:current_environment)) }
+        result = find_class(name_path)
+        unless result.is_a?(Module)
+          raise RuntimeError, "Loading of #{name} using relative path: '#{loaded_path}' did not create expected class"
+        end
+      end
+    end
+    return nil unless result.is_a?(Module)
+
+    result
+  end
+  private_class_method :provide_from_string
+
+  def self.find_class(name_path)
+    name_path.reduce(Object) do |ns, name|
+      ns.const_get(name, false) # don't search ancestors
+    rescue NameError
+      return nil
+    end
+  end
+  private_class_method :find_class
+
+  def self.paths_for_name(fq_named_parts)
+    # search two entries, one where all parts are decamelized, and one with names just downcased
+    # TODO:this is not perfect - it will not produce the correct mix if a mix of styles are used
+    # The alternative is to test many additional paths.
+    #
+    [fq_named_parts.map { |part| de_camel(part) }.join('/'), fq_named_parts.join('/').downcase]
+  end
+  private_class_method :paths_for_name
+
+  def self.de_camel(fq_name)
+    fq_name.to_s.gsub(/::/, '/')
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .tr("-", "_")
+           .downcase
+  end
+  private_class_method :de_camel
+end
+end
+end

data/lib/puppet/pops/types/implementation_registry.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Puppet::Pops
+module Types
+  # The {ImplementationRegistry} maps names types in the Puppet Type System to names of corresponding implementation
+  # modules/classes. Each mapping is unique and bidirectional so that for any given type name there is only one
+  # implementation and vice versa.
+  #
+  # @api private
+  class ImplementationRegistry
+    TYPE_REGEXP_SUBST = TypeFactory.tuple([PRegexpType::DEFAULT, PStringType::NON_EMPTY])
+
+    # Create a new instance. This method is normally only called once
+    #
+    # @param parent [ImplementationRegistry, nil] the parent of this registry
+    def initialize(parent = nil)
+      @parent = parent
+      @type_names_per_implementation = {}
+      @implementations_per_type_name = {}
+      @type_name_substitutions = []
+      @impl_name_substitutions = []
+    end
+
+    # Register a bidirectional type mapping.
+    #
+    # @overload register_type_mapping(runtime_type, puppet_type)
+    #   @param runtime_type [PRuntimeType] type that represents the runtime module or class to map to a puppet type
+    #   @param puppet_type [PAnyType] type that will be mapped to the runtime module or class
+    # @overload register_type_mapping(runtime_type, pattern_replacement)
+    #   @param runtime_type [PRuntimeType] type containing the pattern and replacement to map the runtime type to a puppet type
+    #   @param puppet_type [Array(Regexp,String)] the pattern and replacement to map a puppet type to a runtime type
+    def register_type_mapping(runtime_type, puppet_type_or_pattern, _ = nil)
+      TypeAsserter.assert_assignable('First argument of type mapping', PRuntimeType::RUBY, runtime_type)
+      expr = runtime_type.name_or_pattern
+      if expr.is_a?(Array)
+        TypeAsserter.assert_instance_of('Second argument of type mapping', TYPE_REGEXP_SUBST, puppet_type_or_pattern)
+        register_implementation_regexp(puppet_type_or_pattern, expr)
+      else
+        TypeAsserter.assert_instance_of('Second argument of type mapping', PTypeType::DEFAULT, puppet_type_or_pattern)
+        register_implementation(puppet_type_or_pattern, expr)
+      end
+    end
+
+    # Register a bidirectional namespace mapping
+    #
+    # @param type_namespace [String] the namespace for the puppet types
+    # @param impl_namespace [String] the namespace for the implementations
+    def register_implementation_namespace(type_namespace, impl_namespace, _ = nil)
+      ns = TypeFormatter::NAME_SEGMENT_SEPARATOR
+      register_implementation_regexp(
+        [/\A#{type_namespace}#{ns}(\w+)\z/, "#{impl_namespace}#{ns}\\1"],
+        [/\A#{impl_namespace}#{ns}(\w+)\z/, "#{type_namespace}#{ns}\\1"]
+      )
+    end
+
+    # Register a bidirectional regexp mapping
+    #
+    # @param type_name_subst [Array(Regexp,String)] regexp and replacement mapping type names to runtime names
+    # @param impl_name_subst [Array(Regexp,String)] regexp and replacement mapping runtime names to type names
+    def register_implementation_regexp(type_name_subst, impl_name_subst, _ = nil)
+      @type_name_substitutions << type_name_subst
+      @impl_name_substitutions << impl_name_subst
+      nil
+    end
+
+    # Register a bidirectional mapping between a type and an implementation
+    #
+    # @param type [PAnyType,String] the type or type name
+    # @param impl_module[Module,String] the module or module name
+    def register_implementation(type, impl_module, _ = nil)
+      type = type.name if type.is_a?(PAnyType)
+      impl_module = impl_module.name if impl_module.is_a?(Module)
+      @type_names_per_implementation[impl_module] = type
+      @implementations_per_type_name[type] = impl_module
+      nil
+    end
+
+    # Find the name for the module that corresponds to the given type or type name
+    #
+    # @param type [PAnyType,String] the name of the type
+    # @return [String,nil] the name of the implementation module, or `nil` if no mapping was found
+    def module_name_for_type(type)
+      type = type.name if type.is_a?(PAnyType)
+      name = @parent.module_name_for_type(type) unless @parent.nil?
+      name.nil? ? find_mapping(type, @implementations_per_type_name, @type_name_substitutions) : name
+    end
+
+    # Find the module that corresponds to the given type or type name
+    #
+    # @param type [PAnyType,String] the name of the type
+    # @return [Module,nil] the name of the implementation module, or `nil` if no mapping was found
+    def module_for_type(type)
+      name = module_name_for_type(type)
+      # TODO Shouldn't ClassLoader be module specific?
+      name.nil? ? nil : ClassLoader.provide(name)
+    end
+
+    # Find the type name and loader that corresponds to the given runtime module or module name
+    #
+    # @param impl_module [Module,String] the implementation class or class name
+    # @return [String,nil] the name of the type, or `nil` if no mapping was found
+    def type_name_for_module(impl_module)
+      impl_module = impl_module.name if impl_module.is_a?(Module)
+      name = @parent.type_name_for_module(impl_module) unless @parent.nil?
+      name.nil? ? find_mapping(impl_module, @type_names_per_implementation, @impl_name_substitutions) : name
+    end
+
+    # Find the name for, and then load, the type  that corresponds to the given runtime module or module name
+    # The method will return `nil` if no mapping is found, a TypeReference if a mapping was found but the
+    # loader didn't find the type, or the loaded type.
+    #
+    # @param impl_module [Module,String] the implementation class or class name
+    # @return [PAnyType,nil] the type, or `nil` if no mapping was found
+    def type_for_module(impl_module)
+      name = type_name_for_module(impl_module)
+      if name.nil?
+        nil
+      else
+        TypeParser.singleton.parse(name)
+      end
+    end
+
+    private
+
+    def find_mapping(name, names, substitutions)
+      found = names[name]
+      if found.nil?
+        substitutions.each do |subst|
+          substituted = name.sub(*subst)
+          return substituted unless substituted == name
+        end
+      end
+      found
+    end
+  end
+end
+end