puppet 4.10.0 → 5.0.0

data/lib/puppet/pops/serialization/to_data_converter.rb

@@ -0,0 +1,292 @@
+module Puppet::Pops
+module Serialization
+  # Class that can process an arbitrary object into a value that is assignable to `Data`.
+  #
+  # @api public
+  class ToDataConverter
+    include Evaluator::Runtime3Support
+
+    # Convert the given _value_ according to the given _options_ and return the result of the conversion
+    #
+    # @param value [Object] the value to convert
+    # @param options {Symbol => <Boolean,String>} options hash
+    # @option options [Boolean] :rich_data `true` if rich data is enabled
+    # @option options [Boolean] :local_references use local references instead of duplicating complex entries
+    # @option options [Boolean] :type_by_reference `true` if Object types are converted to references rather than embedded.
+    # @option options [Boolean] :symbol_as_string `true` if Symbols should be converted to strings (with type loss)
+    # @option options [String] :path_prefix String to prepend to path in warnings and errors
+    # @return [Data] the processed result. An object assignable to `Data`.
+    #
+    # @api public
+    def self.convert(value, options = EMPTY_HASH)
+      new(options).convert(value)
+    end
+
+    # Create a new instance of the processor
+    #
+    # @param options {Symbol => Object} options hash
+    # @option options [Boolean] :rich_data `true` if rich data is enabled
+    # @option options [Boolean] :local_references use local references instead of duplicating complex entries
+    # @option options [Boolean] :type_by_reference `true` if Object types are converted to references rather than embedded.
+    # @option options [Boolean] :symbol_as_string `true` if Symbols should be converted to strings (with type loss)
+    # @option options [String] :message_prefix String to prepend to path in warnings and errors
+    # @option semantic [Object] :semantic object to pass to the issue reporter
+    def initialize(options = EMPTY_HASH)
+      @type_by_reference = options[:type_by_reference]
+      @type_by_reference = true if @type_by_reference.nil?
+
+      @local_reference = options[:local_reference]
+      @local_reference = true if @local_reference.nil?
+
+      @symbol_as_string = options[:symbol_as_string]
+      @symbol_as_string = false if @symbol_as_string.nil?
+
+      @rich_data = options[:rich_data]
+      @rich_data = false if @rich_data.nil?
+
+      @message_prefix = options[:message_prefix]
+      @semantic = options[:semantic]
+    end
+
+    # Convert the given _value_
+    #
+    # @param value [Object] the value to convert
+    # @return [Data] the processed result. An object assignable to `Data`.
+    #
+    # @api public
+    def convert(value)
+      @path = []
+      @values = {}
+      to_data(value)
+    end
+
+    private
+
+    def path_to_s
+      s = @message_prefix || ''
+      s << JsonPath.to_json_path(@path)[1..-1]
+      s
+    end
+
+    def to_data(value)
+      if value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
+        value
+      elsif value.is_a?(Symbol)
+        if value == :default
+          { PCORE_TYPE_KEY => PCORE_TYPE_DEFAULT }
+        else
+          @symbol_as_string ? value.to_s : { PCORE_TYPE_KEY => PCORE_TYPE_SYMBOL, PCORE_VALUE_KEY => value.to_s }
+        end
+      elsif value.instance_of?(Array)
+        process(value) do
+          result = []
+          value.each_with_index do |elem, index|
+            with(index) { result << to_data(elem) }
+          end
+          result
+        end
+      elsif value.instance_of?(Hash)
+        process(value) do
+          if value.keys.all? { |key| key.is_a?(String) }
+            result = {}
+            value.each_pair { |key, elem| with(key) { result[key] = to_data(elem) } }
+            result
+          else
+            non_string_keyed_hash_to_data(value)
+          end
+        end
+      elsif value.instance_of?(Types::PSensitiveType::Sensitive)
+        process(value) do
+          { PCORE_TYPE_KEY => PCORE_TYPE_SENSITIVE, PCORE_VALUE_KEY => to_data(value.unwrap) }
+        end
+      else
+        unknown_to_data(value)
+      end
+    end
+
+    # If `:local_references` is enabled, then the `object_id` will be associated with the current _path_ of
+    # the context the first time this method is called. The method then returns the result of  yielding to
+    # the given block. Subsequent calls with a value that has the same `object_id` will instead return a
+    # reference based on the given path.
+    #
+    # If `:local_references` is disabled, then this method performs a check for endless recursion before
+    # it yields to the given block. The result of yielding is returned.
+    #
+    # @param value [Object] the value
+    # @yield The block that will produce the data for the value
+    # @return [Data] the result of yielding to the given block, or a hash denoting a reference
+    #
+    # @api private
+    def process(value, &block)
+      if @local_reference
+        id = value.object_id
+        ref = @values[id]
+        if ref.nil?
+          @values[id] = @path.dup
+          yield
+        elsif ref.instance_of?(Hash)
+          ref
+        else
+          json_ref = JsonPath.to_json_path(ref)
+          if json_ref.nil?
+            # Complex key and hence no way to reference the prior value. The value must therefore be
+            # duplicated which in turn introduces a risk for endless recursion in case of self
+            # referencing structures
+            with_recursive_guard(value, &block)
+          else
+            @values[id] = { PCORE_TYPE_KEY => PCORE_LOCAL_REF_SYMBOL, PCORE_VALUE_KEY => json_ref }
+          end
+        end
+      else
+        with_recursive_guard(value, &block)
+      end
+    end
+
+    # Pushes `key` to the end of the path and yields to the given block. The
+    # `key` is popped when the yield returns.
+    # @param key [Object] the key to push on the current path
+    # @yield The block that will produce the returned value
+    # @return [Object] the result of yielding to the given block
+    #
+    # @api private
+    def with(key)
+      @path.push(key)
+      value = yield
+      @path.pop
+      value
+    end
+
+    # @param value [Object] the value to use when checking endless recursion
+    # @yield The block that will produce the data
+    # @return [Data] the result of yielding to the given block
+    def with_recursive_guard(value)
+      id = value.object_id
+      if @recursive_lock
+        if @recursive_lock.include?(id)
+          serialization_issue(Issues::SERIALIZATION_ENDLESS_RECURSION, :type_name => value.class.name)
+        end
+        @recursive_lock[id] = true
+      else
+        @recursive_lock = { id => true }
+      end
+      v = yield
+      @recursive_lock.delete(id)
+      v
+    end
+
+    def unknown_to_data(value)
+      @rich_data ? value_to_data_hash(value) : unknown_to_string_with_warning(value)
+    end
+
+    def unknown_key_to_string_with_warning(value)
+      str = value.to_s
+      serialization_issue(Issues::SERIALIZATION_UNKNOWN_KEY_CONVERTED_TO_STRING, :path => path_to_s, :klass => value.class, :value => str)
+      str
+    end
+
+    def unknown_to_string_with_warning(value)
+      str = value.to_s
+      serialization_issue(Issues::SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING, :path => path_to_s, :klass => value.class, :value => str)
+      str
+    end
+
+    def non_string_keyed_hash_to_data(hash)
+      if @rich_data
+        to_key_extended_hash(hash)
+      else
+        result = {}
+        hash.each_pair do |key, value|
+          if key.is_a?(Symbol) && @symbol_as_string
+            key = key.to_s
+          elsif !key.is_a?(String)
+            key = unknown_key_to_string_with_warning(key)
+          end
+          with(key) { result[key] = to_data(value) }
+        end
+        result
+      end
+    end
+
+    # A Key extended hash is a hash whose keys are not entirely strings. Such a hash
+    # cannot be safely represented as JSON or YAML
+    #
+    # @param hash {Object => Object} the hash to process
+    # @return [String => Data] the representation of the extended hash
+    def to_key_extended_hash(hash)
+      key_value_pairs = []
+      hash.each_pair do |key, value|
+        key = to_data(key)
+        key_value_pairs << key
+        key_value_pairs << with(key) { to_data(value) }
+      end
+      { PCORE_TYPE_KEY => PCORE_TYPE_HASH, PCORE_VALUE_KEY => key_value_pairs }
+    end
+
+    def value_to_data_hash(value)
+      pcore_type = value.is_a?(Types::PuppetObject) ? value._pcore_type : Types::TypeCalculator.singleton.infer(value)
+      if pcore_type.is_a?(Puppet::Pops::Types::PRuntimeType)
+        unknown_to_string_with_warning(value)
+      else
+        pcore_tv = pcore_type_to_data(pcore_type)
+        if pcore_type.roundtrip_with_string?
+          {
+            PCORE_TYPE_KEY => pcore_tv,
+
+            # Scalar values are stored using their default string representation
+            PCORE_VALUE_KEY => Types::StringConverter.singleton.convert(value)
+          }
+        elsif pcore_type.implementation_class.respond_to?(:_pcore_init_from_hash)
+          process(value) do
+            {
+              PCORE_TYPE_KEY => pcore_tv,
+            }.merge(to_data(value._pcore_init_hash))
+          end
+        else
+          process(value) do
+            (names, types, required_count) = pcore_type.parameter_info(value.class)
+            args = names.map { |name| value.send(name) }
+
+            # Pop optional arguments that are default
+            while args.size > required_count
+              break unless pcore_type[names[args.size-1]].default_value?(args.last)
+              args.pop
+            end
+            result = {
+              PCORE_TYPE_KEY => pcore_tv
+            }
+            args.each_with_index do |val, idx|
+              key = names[idx]
+              with(key) { result[key] = to_data(val) }
+            end
+            result
+          end
+        end
+      end
+    end
+
+    def pcore_type_to_data(pcore_type)
+      type_name = pcore_type.name
+      if @type_by_reference  || type_name.start_with?('Pcore::')
+        type_name
+      else
+        with(PCORE_TYPE_KEY) { to_data(pcore_type) }
+      end
+    end
+    private :pcore_type_to_data
+
+    def serialization_issue(issue, options = EMPTY_HASH)
+      semantic = @semantic
+      if semantic.nil?
+        stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+        if stacktrace.size > 0
+          file, line = stacktrace[0]
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
+        else
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, EMPTY_HASH)
+        end
+      end
+      optionally_fail(issue,  semantic, options)
+    end
+  end
+end
+end

data/lib/puppet/pops/serialization.rb

@@ -6,12 +6,36 @@ module Serialization
 
   class SerializationError < Puppet::Error
   end
+
+  PCORE_TYPE_KEY = '__pcore_type__'.freeze
+
+  # Key used when the value can be represented as, and recreated from, a single string that can
+  # be passed to a `from_string` method or an array of values that can be passed to the default
+  # initializer method.
+  PCORE_VALUE_KEY = '__pcore_value__'.freeze
+
+  # Type key used for hashes that contain keys that are not of type String
+  PCORE_TYPE_HASH = 'Hash'.freeze
+
+  # Type key used for symbols
+  PCORE_TYPE_SENSITIVE = 'Sensitive'.freeze
+
+  # Type key used for symbols
+  PCORE_TYPE_SYMBOL = 'Symbol'.freeze
+
+  # Type key used for Default
+  PCORE_TYPE_DEFAULT = 'Default'.freeze
+
+  # Type key used for document local references
+  PCORE_LOCAL_REF_SYMBOL = 'LocalRef'.freeze
 end
 end
 
+require_relative 'serialization/json_path'
+require_relative 'serialization/from_data_converter'
+require_relative 'serialization/to_data_converter'
 require_relative 'serialization/serializer'
 require_relative 'serialization/deserializer'
 require_relative 'serialization/json'
 require_relative 'serialization/time_factory'
-require_relative 'serialization/rgen'
 require_relative 'serialization/object'

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

@@ -109,7 +109,7 @@ module Time
           rescue ArgumentError
           end
         end
-        raise ArgumentError, "Unable to parse '#{str}' using any of the formats #{format.join(', ')}"
+        raise ArgumentError, _("Unable to parse '%{str}' using any of the formats %{formats}") % { str: str, formats: format.join(', ') }
       end
       format = FormatParser.singleton.parse_format(format) unless format.is_a?(Format)
       format.parse(str)
@@ -130,7 +130,7 @@ module Time
         # Add seconds
         Timespan.new(@nsecs + (o * NSECS_PER_SEC).to_i)
       else
-        raise ArgumentError, "#{a_an_uc(o)} cannot be added to a Timespan" unless o.is_a?(Timespan)
+        raise ArgumentError, _("%{klass} cannot be added to a Timespan") % { klass: a_an_uc(o) } unless o.is_a?(Timespan)
       end
     end
 
@@ -142,7 +142,7 @@ module Time
         # Subtract seconds
         Timespan.new(@nsecs - (o * NSECS_PER_SEC).to_i)
       else
-        raise ArgumentError, "#{a_an_uc(o)} cannot be subtracted from a Timespan"
+        raise ArgumentError, _("%{klass} cannot be subtracted from a Timespan") % { klass: a_an_uc(o) }
       end
     end
 
@@ -155,7 +155,7 @@ module Time
       when Integer, Float
         Timespan.new((@nsecs * o).to_i)
       else
-        raise ArgumentError, "A Timestamp cannot be multiplied by #{a_an(o)}"
+        raise ArgumentError, _("A Timestamp cannot be multiplied by %{klass}") % { klass: a_an(o) }
       end
     end
 
@@ -166,7 +166,7 @@ module Time
       when Float
         to_f.divmod(o)
       else
-        raise ArgumentError, "Can not do modulus on a Timespan using a #{a_an(o)}"
+        raise ArgumentError, _("Can not do modulus on a Timespan using a %{klass}") % { klass: a_an(o) }
       end
     end
 
@@ -186,7 +186,7 @@ module Time
       when Integer, Float
         Timespan.new(@nsecs.div(o))
       else
-        raise ArgumentError, "A Timespan cannot be divided by #{a_an(o)}"
+        raise ArgumentError, _("A Timespan cannot be divided by %{klass}") % { klass: a_an(o) }
       end
     end
 
@@ -473,7 +473,7 @@ module Time
         def nanoseconds(group)
           # Using %L or %N to parse a string only makes sense when they are considered to be fractions. Using them
           # as a total quantity would introduce ambiguities.
-          raise ArgumentError, 'Format specifiers %L and %N denotes fractions and must be used together with a specifier of higher magnitude' if use_total?
+          raise ArgumentError, _('Format specifiers %L and %N denotes fractions and must be used together with a specifier of higher magnitude') if use_total?
           n = group.to_i
           p = 9 - group.length
           p <= 0 ? n : n * 10 ** p
@@ -549,13 +549,13 @@ module Time
 
       def parse(timespan)
         md = regexp.match(timespan)
-        raise ArgumentError, "Unable to parse '#{timespan}' using format '#{@format}'" if md.nil?
+        raise ArgumentError, _("Unable to parse '%{timespan}' using format '%{format}'") % { timespan: timespan, format: @format } if md.nil?
         nanoseconds = 0
         md.captures.each_with_index do |group, index|
           segment = @segments[index]
           next if segment.is_a?(LiteralSegment)
           group.lstrip!
-          raise ArgumentError, "Unable to parse '#{timespan}' using format '#{@format}'" unless group =~ /\A[0-9]+\z/
+          raise ArgumentError, _("Unable to parse '%{timespan}' using format '%{format}'") % { timespan: timespan, format: @format } unless group =~ /\A[0-9]+\z/
           nanoseconds += segment.nanoseconds(group)
         end
         Timespan.new(timespan.start_with?('-') ? -nanoseconds : nanoseconds)
@@ -607,7 +607,7 @@ module Time
       ]
 
       def bad_format_specifier(format, start, position)
-        "Bad format specifier '#{format[start,position-start]}' in '#{format}', at position #{position}"
+        _("Bad format specifier '%{expression}' in '%{format}', at position %{position}") % { expression: format[start,position-start], format: format, position: position }
       end
 
       def append_literal(bld, codepoint)
@@ -625,7 +625,7 @@ module Time
 
       def internal_parse(str)
         bld = []
-        raise ArgumentError, 'Format must be a String' unless str.is_a?(String)
+        raise ArgumentError, _('Format must be a String') unless str.is_a?(String)
         highest = -1
         state = STATE_LITERAL
         padchar = '0'

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

@@ -1,8 +1,8 @@
 module Puppet::Pops
 module Time
 class Timestamp < TimeData
-  DEFAULT_FORMATS_WO_TZ = ['%FT%T.L', '%FT%T', '%F']
-  DEFAULT_FORMATS = ['%FT%T.%L %Z', '%FT%T %Z', '%F %Z'] + DEFAULT_FORMATS_WO_TZ
+  DEFAULT_FORMATS_WO_TZ = ['%FT%T.%N', '%FT%T', '%F']
+  DEFAULT_FORMATS = ['%FT%T.%N %Z', '%FT%T %Z', '%F %Z'] + DEFAULT_FORMATS_WO_TZ
 
   CURRENT_TIMEZONE = 'current'.freeze
   KEY_TIMEZONE = 'timezone'.freeze
@@ -37,7 +37,7 @@ class Timestamp < TimeData
     else
       hash = DateTime._strptime(timezone, '%z')
       offset = hash.nil? ? nil : hash[:offset]
-      raise ArgumentError, "Illegal timezone '#{timezone}'" if offset.nil?
+      raise ArgumentError, _("Illegal timezone '%{timezone}'") % { timezone: timezone } if offset.nil?
       offset
     end
   end
@@ -78,13 +78,13 @@ class Timestamp < TimeData
         rescue ArgumentError
         end
       end
-      raise ArgumentError, "Unable to parse '#{str}' using any of the formats #{format.join(', ')}" if parsed.nil?
+      raise ArgumentError, _("Unable to parse '%{str}' using any of the formats %{formats}") % { str: str, formats: format.join(', ') } if parsed.nil?
     else
       assert_no_tz_extractor(format) if has_timezone
       begin
         parsed = DateTime.strptime(str, format)
       rescue ArgumentError
-        raise ArgumentError, "Unable to parse '#{str}' using format '#{format}'"
+        raise ArgumentError, _("Unable to parse '%{str}' using format '%{format}'") % { str: str, format: format }
       end
     end
     parsed_time = parsed.to_time
@@ -94,7 +94,7 @@ class Timestamp < TimeData
 
   def self.assert_no_tz_extractor(format)
     if format =~ /[^%]%[zZ]/
-      raise ArgumentError, 'Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument'
+      raise ArgumentError, _('Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument')
     end
   end
 
@@ -113,7 +113,7 @@ class Timestamp < TimeData
     when Integer, Float
       Timestamp.new(@nsecs + (o * NSECS_PER_SEC).to_i)
     else
-      raise ArgumentError, "#{a_an_uc(o)} cannot be added to a Timestamp"
+      raise ArgumentError, _("%{klass} cannot be added to a Timestamp") % { klass: a_an_uc(o) }
     end
   end
 
@@ -128,7 +128,7 @@ class Timestamp < TimeData
       # Subtract seconds
       Timestamp.new(@nsecs - (o * NSECS_PER_SEC).to_i)
     else
-      raise ArgumentError, "#{a_an_uc(o)} cannot be subtracted from a Timestamp"
+      raise ArgumentError, _("%{klass} cannot be subtracted from a Timestamp") % { klass: a_an_uc(o) }
     end
   end
 

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

@@ -7,17 +7,17 @@ KEY_ANNOTATIONS = 'annotations'.freeze
 #
 # @api public
 module Annotatable
-  TYPE_ANNOTATION_KEY_TYPE = PType::DEFAULT # TBD
-  TYPE_ANNOTATION_VALUE_TYPE = PStructType::DEFAULT #TBD
-  TYPE_ANNOTATIONS = PHashType.new(TYPE_ANNOTATION_KEY_TYPE, TYPE_ANNOTATION_VALUE_TYPE)
+  TYPE_ANNOTATIONS = PHashType.new(PType.new(PTypeReferenceType.new('Annotation')), PHashType::DEFAULT)
 
   # @return [{PType => PStructType}] the map of annotations
   # @api public
-  attr_reader :annotations
+  def annotations
+    @annotations.nil? ? EMPTY_HASH : @annotations
+  end
 
   # @api private
-  def init_annotatable(i12n_hash)
-    @annotations = i12n_hash[KEY_ANNOTATIONS].freeze
+  def init_annotatable(init_hash)
+    @annotations = init_hash[KEY_ANNOTATIONS].freeze
   end
 
   # @api private
@@ -26,7 +26,7 @@ module Annotatable
   end
 
   # @api private
-  def i12n_hash
+  def _pcore_init_hash
     result = {}
     result[KEY_ANNOTATIONS] = @annotations unless @annotations.nil?
     result

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

@@ -0,0 +1,71 @@
+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'.freeze
+
+    # 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 i12n 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)
+          i12n = o.annotations[_pcore_type]
+          i12n = yield if i12n.nil? && block_given?
+        else
+          i12n = yield if block_given?
+        end
+        adapter = associate_adapter(_pcore_type.from_hash(i12n), o) unless i12n.nil?
+      end
+      adapter
+    end
+
+    # Forces the creation or removal of an annotation of this type.
+    # If `i21n` is a hash, a new annotation is created and returned
+    # If `i12n` is `nil`, then the annotation is cleared and the previous annotation is returned.
+    #
+    # @param o [Object] object to annotate
+    # @param i12n [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

@@ -1,5 +1,3 @@
-require 'rgen/metamodel_builder'
-
 module Puppet::Pops
 module Types
 # The ClassLoader provides a Class instance given a class name or a meta-type.
@@ -86,24 +84,24 @@ class ClassLoader
     # If class is already loaded, try this first
     result = find_class(name_path)
 
-    unless result.is_a?(Class)
+    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?(Class)
+        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?(Class)
+    return nil unless result.is_a?(Module)
     result
   end
 
   def self.find_class(name_path)
     name_path.reduce(Object) do |ns, name|
       begin
-        ns.const_get(name)
+        ns.const_get(name, false) # don't search ancestors
       rescue NameError
         return nil
       end

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

@@ -4,12 +4,12 @@
 module Puppet::Pops::Types
   class Enumeration
     def self.enumerator(o)
-      Puppet.deprecation_warning('Enumeration.enumerator is deprecated. Use Iterable.on instead')
+      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
       Iterable.on(o)
     end
 
     def enumerator(o)
-      Puppet.deprecation_warning('Enumeration.enumerator is deprecated. Use Iterable.on instead')
+      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
       Iterable.on(o)
     end
   end

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

@@ -132,13 +132,13 @@ module Puppet::Pops::Types
     def reverse_each(&block)
       # Default implementation cannot propagate reverse_each to a new enumerator so chained
       # calls must put reverse_each last.
-      raise ArgumentError 'Step is not implemented'
+      raise ArgumentError 'reverse_each() is not implemented'
     end
 
     def step(step, &block)
       # Default implementation cannot propagate step to a new enumerator so chained
       # calls must put stepping last.
-      raise ArgumentError 'Step is not implemented'
+      raise ArgumentError 'step() is not implemented'
     end
 
     def to_a

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

@@ -67,7 +67,7 @@ class PBinaryType < PAnyType
     def self.from_string(encoded_string)
       enc = encoded_string.encoding.name
       unless encoded_string.valid_encoding?
-        raise ArgumentError, "The given string in encoding '#{enc}' is invalid. Cannot create a Binary UTF-8 representation"
+        raise ArgumentError, _("The given string in encoding '%{enc}' is invalid. Cannot create a Binary UTF-8 representation") % { enc: enc }
       end
       # Convert to UTF-8 (if not already UTF-8), and then to binary
       encoded_string = (enc == "UTF-8") ? encoded_string.dup : encoded_string.encode('UTF-8')
@@ -137,6 +137,12 @@ class PBinaryType < PAnyType
     self.class == o.class
   end
 
+  # Binary uses the strict base64 format as its string representation
+  # @return [TrueClass] true
+  def roundtrip_with_string?
+    true
+  end
+
   # @api private
   def self.new_function(_, loader)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_Binary, loader) do