puppet 5.3.4 → 6.29.0

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

@@ -9,8 +9,7 @@ module Serialization
 class ObjectReader
   include InstanceReader
 
-  def read(impl_class, value_count, deserializer)
-    type = impl_class._pcore_type
+  def read(type, impl_class, value_count, deserializer)
     (names, types, required_count) = type.parameter_info(impl_class)
     max = names.size
     unless value_count >= required_count && value_count <= max
@@ -25,7 +24,7 @@ class ObjectReader
         Types::TypeAsserter.assert_instance_of(nil, ptype, arg) { "#{type.name}[#{names[index]}]" } unless arg == :default
       else
         attr = type[names[index]]
-        raise Serialization::SerializationError, _("Missing default value for %{type_name}[%{name}]") % { type_name: type.name, name: names[index] } unless attr.value?
+        raise Serialization::SerializationError, _("Missing default value for %{type_name}[%{name}]") % { type_name: type.name, name: names[index] } unless attr && attr.value?
         args << attr.value
       end
     end
@@ -43,7 +42,7 @@ class ObjectWriter
 
   def write(type, value, serializer)
     impl_class = value.class
-    (names, types, required_count) = type.parameter_info(impl_class)
+    (names, _, required_count) = type.parameter_info(impl_class)
     args = names.map { |name| value.send(name) }
 
     # Pop optional arguments that are default

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

@@ -108,7 +108,8 @@ module Serialization
           value.instance_of?(SemanticPuppet::VersionRange),
           value.instance_of?(Time::Timestamp),
           value.instance_of?(Time::Timespan),
-          value.instance_of?(Types::PBinaryType::Binary)
+          value.instance_of?(Types::PBinaryType::Binary),
+          value.is_a?(URI)
         push_written(value)
         @writer.write(value)
       when value.instance_of?(Array)

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

@@ -11,10 +11,10 @@ module Serialization
     # @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] :local_reference 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
+    # @option options [String] :message_prefix String to prepend to in warnings and errors
     # @return [Data] the processed result. An object assignable to `Data`.
     #
     # @api public
@@ -70,7 +70,15 @@ module Serialization
 
     def to_data(value)
       if value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
-        value
+        if @rich_data && value.is_a?(String) && value.encoding == Encoding::ASCII_8BIT
+          # Transform the binary string to rich Binary
+          {
+            PCORE_TYPE_KEY => PCORE_TYPE_BINARY,
+            PCORE_VALUE_KEY => Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(value).to_s
+          }
+        else
+          value
+        end
       elsif :default == value
         if @rich_data
           { PCORE_TYPE_KEY => PCORE_TYPE_DEFAULT }
@@ -96,7 +104,7 @@ module Serialization
         end
       elsif value.instance_of?(Hash)
         process(value) do
-          if value.keys.all? { |key| key.is_a?(String) }
+          if value.keys.all? { |key| key.is_a?(String) && key != PCORE_TYPE_KEY }
             result = {}
             value.each_pair { |key, elem| with(key) { result[key] = to_data(elem) } }
             result
@@ -188,17 +196,21 @@ module Serialization
     end
 
     def unknown_key_to_string_with_warning(value)
-      str = value.to_s
+      str = unknown_to_string(value)
       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
+      str = unknown_to_string(value)
       serialization_issue(Issues::SERIALIZATION_UNKNOWN_CONVERTED_TO_STRING, :path => path_to_s, :klass => value.class, :value => str)
       str
     end
 
+    def unknown_to_string(value)
+      value.is_a?(Regexp) ? Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(value) : value.to_s
+    end
+
     def non_string_keyed_hash_to_data(hash)
       if @rich_data
         to_key_extended_hash(hash)
@@ -252,7 +264,7 @@ module Serialization
           end
         else
           process(value) do
-            (names, types, required_count) = pcore_type.parameter_info(value.class)
+            (names, _, required_count) = pcore_type.parameter_info(value.class)
             args = names.map { |name| value.send(name) }
 
             # Pop optional arguments that are default
@@ -286,12 +298,12 @@ module Serialization
     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
+        tos = Puppet::Pops::PuppetStack.top_of_stack
+        if tos.empty?
           semantic = Puppet::Pops::SemanticError.new(issue, nil, EMPTY_HASH)
+        else
+          file, line = stacktrace
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
         end
       end
       optionally_fail(issue,  semantic, options)

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

@@ -0,0 +1,226 @@
+module Puppet::Pops
+module Serialization
+
+  # Class that can process an arbitrary object into a value that is assignable to `Data`
+  # and where contents is converted from rich data to one of:
+  # * Numeric (Integer, Float)
+  # * Boolean 
+  # * Undef (nil)
+  # * String
+  # * Array
+  # * Hash
+  # 
+  # The conversion is lossy - the result cannot be deserialized to produce the original data types.
+  # All rich values are transformed to strings..
+  # Hashes with rich keys are transformed to use string representation of such keys.
+  #
+  # @api public
+  class ToStringifiedConverter
+    include Evaluator::Runtime3Support
+
+    # Converts 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 [String] :message_prefix String to prepend to in warnings and errors
+    # @option options [String] :semantic object (AST) to pass to the issue reporter
+    # @return [Data] the processed result. An object assignable to `Data` with rich data stringified.
+    #
+    # @api public
+    def self.convert(value, options = EMPTY_HASH)
+      new(options).convert(value)
+    end
+
+    # Creates a new instance of the processor
+    #
+    # @param options {Symbol => Object} options hash
+    # @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)
+      @message_prefix = options[:message_prefix]
+      @semantic = options[:semantic]
+    end
+
+    # Converts the given _value_
+    #
+    # @param value [Object] the value to convert
+    # @return [Data] the processed result. An object assignable to `Data` with rich data stringified.
+    #
+    # @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.instance_of?(String)
+        to_string_or_binary(value)
+      elsif value.nil? || Types::PScalarDataType::DEFAULT.instance?(value)
+        value
+      elsif :default == value
+        'default'
+      elsif value.is_a?(Symbol)
+        value.to_s
+      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) && key != PCORE_TYPE_KEY && key != PCORE_VALUE_KEY }
+            result = {}
+            value.each_pair { |key, elem| with(key) { result[key] = to_data(elem) } }
+            result
+          else
+            non_string_keyed_hash_to_data(value)
+          end
+        end
+      else
+        unknown_to_string(value)
+      end
+    end
+
+    # Turns an ASCII-8BIT encoded string into a Binary, returns US_ASCII encoded and transforms all other strings to UTF-8
+    # with replacements for non Unicode characters.
+    # If String cannot be represented as UTF-8
+    def to_string_or_binary(value)
+      encoding = value.encoding
+      if encoding == Encoding::ASCII_8BIT
+        Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(value).to_s
+      else
+        # Transform to UTF-8 (do not assume UTF-8 is correct) with source invalid byte
+        # sequences and UTF-8 undefined characters replaced by the default unicode uFFFD character
+        # (black diamond with question mark).
+        value.encode(Encoding::UTF_8, encoding, :invalid => :replace, :undef => :replace)
+      end
+    end
+
+    # 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)
+      with_recursive_guard(value, &block)
+    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
+
+    # A hash key that is non conforming
+    def unknown_key_to_string(value)
+      unknown_to_string(value)
+    end
+
+    def unknown_to_string(value)
+      if value.is_a?(Regexp)
+        return Puppet::Pops::Types::PRegexpType.regexp_to_s_with_delimiters(value)
+
+      elsif value.instance_of?(Types::PSensitiveType::Sensitive)
+        # to_s does not differentiate between instances - if they were used as keys in a hash
+        # the stringified result would override all Sensitive keys with the last such key's value
+        # this adds object_id.
+        #
+        return "#<#{value}:#{value.object_id}>"
+
+      elsif value.is_a?(Puppet::Pops::Types::PObjectType)
+        # regular to_s on an ObjectType gives the entire definition
+        return value.name
+
+      end
+
+      # Do a to_s on anything else
+      result = value.to_s
+
+      # The result may be ascii-8bit encoded without being a binary (low level object.inspect returns ascii-8bit string)
+      # This can be the case if runtime objects have very simple implementation (no to_s or inspect method).
+      # They are most likely not of Binary nature. Therefore the encoding is forced and only if it errors
+      # will the result be taken as binary and encoded as base64 string.
+      if result.encoding == Encoding::ASCII_8BIT
+        begin
+          result.force_encoding(Encoding::UTF_8)
+        rescue
+          # The result cannot be represented in UTF-8, make it a binary Base64 encoded string
+          Puppet::Pops::Types::PBinaryType::Binary.from_binary_string(result).to_s
+        end
+      end
+      result
+    end
+
+    def non_string_keyed_hash_to_data(hash)
+      result = {}
+      hash.each_pair do |key, value|
+        if key.is_a?(Symbol)
+          key = key.to_s
+        elsif !key.is_a?(String)
+          key = unknown_key_to_string(key)
+        end
+        if key == "__ptype" || key =="__pvalue"
+          key = "reserved key: #{key}"
+        end
+        with(key) { result[key] = to_data(value) }
+      end
+      result
+    end
+
+    def serialization_issue(issue, options = EMPTY_HASH)
+      semantic = @semantic
+      if semantic.nil?
+        tos = Puppet::Pops::PuppetStack.top_of_stack
+        if tos.empty?
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, EMPTY_HASH)
+        else
+          file, line = stacktrace
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
+        end
+      end
+      optionally_fail(issue,  semantic, options)
+    end
+  end
+end
+end

data/lib/puppet/pops/serialization.rb

@@ -7,18 +7,19 @@ module Serialization
   class SerializationError < Puppet::Error
   end
 
-  PCORE_TYPE_KEY = '__pcore_type__'.freeze
+  PCORE_TYPE_KEY = '__ptype'.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
+  PCORE_VALUE_KEY = '__pvalue'.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
+  PCORE_TYPE_BINARY = 'Binary'.freeze
 
   # Type key used for symbols
   PCORE_TYPE_SYMBOL = 'Symbol'.freeze
@@ -34,6 +35,7 @@ end
 require_relative 'serialization/json_path'
 require_relative 'serialization/from_data_converter'
 require_relative 'serialization/to_data_converter'
+require_relative 'serialization/to_stringified_converter'
 require_relative 'serialization/serializer'
 require_relative 'serialization/deserializer'
 require_relative 'serialization/json'

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

@@ -1,3 +1,5 @@
+require 'puppet/concurrent/thread_local_singleton'
+
 module Puppet::Pops
 module Time
   NSECS_PER_USEC = 1000
@@ -259,7 +261,7 @@ module Time
           add_unless_zero(result, KEY_NANOSECONDS, n % 1000)
           n /= 1000
           add_unless_zero(result, KEY_MICROSECONDS, n % 1000)
-          add_unless_zero(result, KEY_MILLISECONDS, n /= 1000)
+          add_unless_zero(result, KEY_MILLISECONDS, n / 1000)
         end
         result[KEY_NEGATIVE] = true if negative?
       end
@@ -581,9 +583,7 @@ module Time
 
     # Parses a string into a Timestamp::Format instance
     class FormatParser
-      def self.singleton
-        @singleton
-      end
+      extend Puppet::Concurrent::ThreadLocalSingleton
 
       def initialize
         @formats = Hash.new { |hash, str| hash[str] = internal_parse(str) }
@@ -706,8 +706,6 @@ module Time
         end
         Format.new(str, bld)
       end
-
-      @singleton = FormatParser.new
     end
 
     class Format

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

@@ -32,8 +32,6 @@ class ClassLoader
     end
   end
 
-  private
-
   def self.provide_from_type(type)
     case type
     when PRuntimeType
@@ -66,12 +64,13 @@ class ClassLoader
     when PPatternType  ; String
     when PEnumType     ; String
     when PFloatType    ; Float
-    when PUndefType      ; NilClass
+    when PUndefType    ; NilClass
     when PCallableType ; Proc
     else
       nil
     end
   end
+  private_class_method :provide_from_type
 
   def self.provide_from_string(name)
     name_path = name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
@@ -97,6 +96,7 @@ class ClassLoader
     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|
@@ -107,6 +107,7 @@ class ClassLoader
       end
     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
@@ -115,6 +116,7 @@ class ClassLoader
     #
     [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(/::/, '/').
@@ -123,6 +125,7 @@ class ClassLoader
     tr("-", "_").
     downcase
   end
+  private_class_method :de_camel
 
 end
 end

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

@@ -8,20 +8,15 @@ module Types
   class ImplementationRegistry
     TYPE_REGEXP_SUBST = TypeFactory.tuple([PRegexpType::DEFAULT, PStringType::NON_EMPTY])
 
-    def self.singleton
-      @singleton ||= new(Loaders.static_loader)
-    end
-
     # Create a new instance. This method is normally only called once
     #
-    # The initializer will create mappings for well known types that can be loaded using the static loader
-    #
-    def initialize(static_loader)
+    # @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 = []
-      TypeParser.type_map.values.each { |type| register_implementation(type.simple_name, type.class.name, static_loader) }
     end
 
     # Register a bidirectional type mapping.
@@ -29,20 +24,18 @@ module Types
     # @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
-    #   @param loader [Loader::Loader] the loader to use when resolving names
     # @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
-    #   @param loader [Loader::Loader] the loader to use when resolving names
-    def register_type_mapping(runtime_type, puppet_type_or_pattern, loader)
+    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, loader)
+        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, loader)
+        register_implementation(puppet_type_or_pattern, expr)
       end
     end
 
@@ -50,23 +43,20 @@ module Types
     #
     # @param type_namespace [String] the namespace for the puppet types
     # @param impl_namespace [String] the namespace for the implementations
-    # @param loader [Loader::Loader] the loader to use when resolving names
-    def register_implementation_namespace(type_namespace, impl_namespace, loader)
+    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"],
-        loader)
+        [/\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
-    # @param loader [Loader::Loader] the loader to use when resolving names
-    def register_implementation_regexp(type_name_subst, impl_name_subst, loader)
-      @type_name_substitutions << [type_name_subst, loader]
-      @impl_name_substitutions << [impl_name_subst, loader]
+    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
 
@@ -74,12 +64,11 @@ module Types
     #
     # @param type [PAnyType,String] the type or type name
     # @param impl_module[Module,String] the module or module name
-    # @param loader [Loader::Loader] the loader to use when resolving names
-    def register_implementation(type, impl_module, loader)
+    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, loader]
-      @implementations_per_type_name[type] = [impl_module, loader]
+      @type_names_per_implementation[impl_module] = type
+      @implementations_per_type_name[type] = impl_module
       nil
     end
 
@@ -89,7 +78,8 @@ module Types
     # @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)
-      find_mapping(type, @implementations_per_type_name, @type_name_substitutions)
+      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
@@ -97,18 +87,19 @@ module Types
     # @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_and_loader = module_name_for_type(type)
+      name = module_name_for_type(type)
       # TODO Shouldn't ClassLoader be module specific?
-      name_and_loader.nil? ? nil : ClassLoader.provide(name_and_loader[0])
+      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 [Array(String,Loader::Loader),nil] the name and loader of the type, or `nil` if no mapping was found
+    # @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)
-      find_mapping(impl_module, @type_names_per_implementation, @impl_name_substitutions)
+      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
@@ -118,20 +109,22 @@ module Types
     # @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_and_loader = type_name_for_module(impl_module)
-      if name_and_loader.nil?
+      name = type_name_for_module(impl_module)
+      if name.nil?
         nil
       else
-        TypeParser.singleton.parse(*name_and_loader)
+        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[0])
-          return [substituted, subst[1]] unless substituted == name
+          substituted = name.sub(*subst)
+          return substituted unless substituted == name
         end
       end
       found