puppet 4.10.1-universal-darwin → 4.10.4-universal-darwin

data/lib/puppet/generate/templates/type/pcore.erb

@@ -34,7 +34,7 @@ Puppet::Resource::ResourceType3.new(
   ],
   {
 <%- title_patterns.each_with_index do |mapping, index| -%>
-    <%= mapping[0] %> => [<%= mapping[1].join(', ')%>]<%= "," if index + 1 < title_patterns.size %>
+    <%= mapping[0] %> => <%= mapping[1] %><%= "," if index + 1 < title_patterns.size %>
 <%- end -%>
   },
   <%= isomorphic -%>,

data/lib/puppet/module_tool/skeleton/templates/generator/examples/init.pp.erb

@@ -1,4 +1,4 @@
-# The baseline for module testing used by Puppet Labs is that each manifest
+# The baseline for module testing used by Puppet Inc. is that each manifest
 # should have a corresponding test manifest that declares that class or defined
 # type.
 #

data/lib/puppet/parser/functions/create_resources.rb

@@ -71,10 +71,18 @@ Puppet::Parser::Functions::newfunction(:create_resources, :arity => -3, :doc =>
 
   if type.start_with? '@@'
     exported = true
+    virtual = true
   elsif type.start_with? '@'
     virtual = true
   end
 
+  if type_name == 'class' && (exported || virtual)
+    # cannot find current evaluator, so use another
+    evaluator = Puppet::Pops::Parser::EvaluatingParser.new.evaluator
+    # optionally fails depending on configured severity of issue
+    evaluator.runtime_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
+  end
+
   instances.map do |title, params|
     # Add support for iteration if title is an array
     resource_titles = title.is_a?(Array) ? title  : [title]

data/lib/puppet/parser/scope.rb

@@ -85,7 +85,7 @@ class Puppet::Parser::Scope
 
     def [](name)
       val = @symbols[name]
-      val.nil? && !@symbols.include?(val) ? super : val
+      val.nil? && !@symbols.include?(name) ? super : val
     end
 
     def is_local_scope?
@@ -481,7 +481,7 @@ class Puppet::Parser::Scope
   #
   # @param [String] name the variable name to lookup
   #
-  # @return Object the value of the variable, or nil if it's not found
+  # @return Object the value of the variable, or if not found; nil if `strict_variables` is false, and thrown :undefined_variable otherwise
   #
   # @api public
   def lookupvar(name, options = EMPTY_HASH)

data/lib/puppet/pops/adapters.rb

@@ -129,7 +129,11 @@ module Adapters
         default_loader
       else
         loader_name = loader_name_by_source(loaders.environment, model, file)
-        loader_name.nil? ? default_loader || loaders.find_loader(nil) : loaders[loader_name]
+        if loader_name.nil?
+          default_loader || loaders[Loader::ENVIRONMENT_PRIVATE]
+        else
+          loaders[loader_name]
+        end
       end
     end
 
@@ -145,12 +149,14 @@ module Adapters
     #
     # The method returns `nil` when no module could be found.
     #
-    # @param scope
-    # @param instance
+    # @param environment [Puppet::Node::Environment] the current environment
+    # @param instance [Model::PopsObject] the AST for the code
+    # @param file [String] the path to the file for the code or `nil`
+    # @return [String] the name of the loader associated with the source
     # @api private
     def self.loader_name_by_source(environment, instance, file)
       file = find_file(instance) if file.nil?
-      return nil if file.nil?
+      return nil if file.nil? || EMPTY_STRING == file
       pn_adapter = PathsAndNameCacheAdapter.adapt(environment) do |a|
         a.paths ||= environment.modulepath.map { |p| Pathname.new(p) }
         a.cache ||= {}

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

@@ -67,12 +67,10 @@ module Runtime3ResourceSupport
   end
 
   def self.find_resource_type(scope, type_name)
-    type_name = type_name.to_s.downcase
     find_builtin_resource_type(scope, type_name) || find_defined_resource_type(scope, type_name)
   end
 
   def self.find_resource_type_or_class(scope, name)
-    type_name = type_name.to_s.downcase
     find_builtin_resource_type(scope, name) || find_defined_resource_type(scope, name) || find_hostclass(scope, name)
   end
 

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

@@ -44,6 +44,30 @@ module Runtime3Support
     diagnostic_producer.accept(issue, semantic, options, except)
   end
 
+  # Optionally (based on severity) Fails the evaluation with a given issue
+  # If the given issue is configured to be of severity < :error it is only reported, and the function returns.
+  # The location the issue is reported against is found is based on the top file/line in the puppet call stack
+  #
+  # @param issue [Issue] the issue to report
+  # @param options [Hash] hash of optional named data elements for the given issue
+  # @return [!] this method may not return, nil if it does
+  # @raise [Puppet::ParseError] an evaluation error initialized from the arguments
+  #
+  def runtime_issue(issue, options={})
+    # Get position from puppet runtime stack
+    stacktrace = Puppet::Pops::PuppetStack.stacktrace()
+    if stacktrace.size > 0
+      file, line = stacktrace[0]
+    else
+      file = nil
+      line = nil
+    end
+    # Use a SemanticError as the sourcepos
+    semantic = Puppet::Pops::SemanticError.new(issue, nil, options.merge({:file => file, :line => line}))
+    optionally_fail(issue,  semantic)
+    nil
+  end
+
   # Binds the given variable name to the given value in the given scope.
   # The reference object `o` is intended to be used for origin information - the 3x scope implementation
   # only makes use of location when there is an error. This is now handled by other mechanisms; first a check
@@ -236,9 +260,14 @@ module Runtime3Support
   # @return [Numeric] value `v` converted to Numeric.
   #
   def coerce_numeric(v, o, scope)
+    if v.is_a?(Numeric)
+      return v
+    end
     unless n = Utils.to_n(v)
       fail(Issues::NOT_NUMERIC, o, {:value => v})
     end
+    # this point is reached if there was a conversion
+    optionally_fail(Issues::NUMERIC_COERCION, o, {:before => v, :after => n})
     n
   end
 
@@ -498,6 +527,8 @@ module Runtime3Support
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
       p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
+      p[Issues::CLASS_NOT_VIRTUALIZABLE]      = Puppet[:strict] == :off ? :warning : Puppet[:strict]
+      p[Issues::NUMERIC_COERCION]             = Puppet[:strict] == :off ? :ignore : Puppet[:strict]
     end
   end
 

data/lib/puppet/pops/issues.rb

@@ -368,6 +368,10 @@ module Issues
     "Resource Defaults are not virtualizable"
   end
 
+  CLASS_NOT_VIRTUALIZABLE = issue :CLASS_NOT_VIRTUALIZABLE do
+    "Classes are not virtualizable"
+  end
+
   # When an attempt is made to use multiple keys (to produce a range in Ruby - e.g. $arr[2,-1]).
   # This is not supported in 3x, but it allowed in 4x.
   #
@@ -502,6 +506,10 @@ module Issues
     "The value '#{value}' cannot be converted to Numeric."
   end
 
+  NUMERIC_COERCION = issue :NUMERIC_COERCION, :before, :after do
+    "The string '#{before}' was automatically coerced to the numerical value #{after}"
+  end
+
   UNKNOWN_FUNCTION = issue :UNKNOWN_FUNCTION, :name do
     "Unknown function: '#{name}'."
   end

data/lib/puppet/pops/loader/loader.rb

@@ -21,6 +21,10 @@
 #
 module Puppet::Pops
 module Loader
+
+ENVIRONMENT = 'environment'.freeze
+ENVIRONMENT_PRIVATE = 'environment private'.freeze
+
 class Loader
   attr_reader :loader_name
 

data/lib/puppet/pops/loader/module_loaders.rb

@@ -21,8 +21,6 @@ module Loader
 # @api private
 #
 module ModuleLoaders
-  ENVIRONMENT = 'environment'.freeze
-
   def self.system_loader_from(parent_loader, loaders)
     # Puppet system may be installed in a fixed location via RPM, installed as a Gem, via source etc.
     # The only way to find this across the different ways puppet can be installed is

data/lib/puppet/pops/loader/static_loader.rb

@@ -171,7 +171,7 @@ class StaticLoader < Loader
   end
 
   def create_resource_type_reference(name)
-    typed_name = TypedName.new(:type, name.downcase)
+    typed_name = TypedName.new(:type, name)
     type = Puppet::Pops::Types::TypeFactory.resource(name)
     @loaded[ typed_name ] = NamedEntry.new(typed_name, type, __FILE__)
   end

data/lib/puppet/pops/loader/type_definition_instantiator.rb

@@ -46,7 +46,7 @@ class TypeDefinitionInstantiator
   end
 
   def self.create_from_model(type_definition, loader)
-    typed_name = TypedName.new(:type, type_definition.name.downcase)
+    typed_name = TypedName.new(:type, type_definition.name)
     type = create_runtime_type(type_definition)
     loader.set_entry(
       typed_name,

data/lib/puppet/pops/loader/typed_name.rb

@@ -12,6 +12,7 @@ class TypedName
   attr_reader :compound_name
 
   def initialize(type, name, name_authority = Pcore::RUNTIME_NAME_AUTHORITY)
+    name = name.downcase
     @type = type
     @name_authority = name_authority
     # relativize the name (get rid of leading ::), and make the split string available

data/lib/puppet/pops/loaders.rb

@@ -94,7 +94,7 @@ class Loaders
     loader = @private_environment_loader
     types = obj_classes.map do |obj_class|
       type = obj_class._ptype
-      typed_name = Loader::TypedName.new(:type, type.name.downcase, name_authority)
+      typed_name = Loader::TypedName.new(:type, type.name, name_authority)
       entry = loader.loaded_entry(typed_name)
       loader.set_entry(typed_name, type, obj_class._plocation) if entry.nil? || entry.value.nil?
       type
@@ -119,7 +119,7 @@ class Loaders
 
     name = name.to_s
     caps_name = Types::TypeFormatter.singleton.capitalize_segments(name)
-    typed_name = Loader::TypedName.new(:type, name.downcase)
+    typed_name = Loader::TypedName.new(:type, name)
     rt3_loader.set_entry(typed_name, Types::PResourceType.new(caps_name), origin)
     nil
   end
@@ -170,15 +170,9 @@ class Loaders
   # @raise [Puppet::ParseError] if no loader can be found
   # @api private
   def find_loader(module_name)
-    if module_name.nil? || module_name == ''
-      # TODO : Later when fdefinition can be private, a decision is needed regarding what that means.
-      #        A private environment loader could be used for logic outside of modules, then only that logic
-      #        would see the definition.
-      #
-      # Use the private loader, this definition may see the environment's dependencies (currently, all modules)
-      loader = private_environment_loader()
-      raise Puppet::ParseError, 'Internal Error: did not find public loader' if loader.nil?
-      loader
+    if module_name.nil? || EMPTY_STRING == module_name
+      # Use the public environment loader
+      public_environment_loader
     else
       # TODO : Later check if definition is private, and then add it to private_loader_for_module
       #
@@ -248,8 +242,6 @@ class Loaders
     # available modules. (3x is everyone sees everything).
     # Puppet binder currently reads confdir/bindings - that is bad, it should be using the new environment support.
 
-    # The environment is not a namespace, so give it a nil "module_name"
-    loader_name = "environment:#{environment.name}"
     # env_conf is setup from the environment_dir value passed into Puppet::Environments::Directories.new
     env_conf = Puppet.lookup(:environments).get_conf(environment.name)
     env_path = env_conf.nil? || !env_conf.is_a?(Puppet::Settings::EnvironmentConf) ? nil : env_conf.path_to_env
@@ -259,7 +251,7 @@ class Loaders
 
     if env_path.nil?
       # Not a real directory environment, cannot work as a module TODO: Drop when legacy env are dropped?
-      loader = add_loader_by_name(Loader::SimpleEnvironmentLoader.new(@runtime3_type_loader, loader_name))
+      loader = add_loader_by_name(Loader::SimpleEnvironmentLoader.new(@runtime3_type_loader, Loader::ENVIRONMENT))
     else
       # View the environment as a module to allow loading from it - this module is always called 'environment'
       loader = Loader::ModuleLoaders.environment_loader_from(@runtime3_type_loader, self, env_path)
@@ -273,7 +265,7 @@ class Loaders
     # Code in the environment gets to see all modules (since there is no metadata for the environment)
     # but since this is not given to the module loaders, they can not load global code (since they can not
     # have prior knowledge about this
-    loader = add_loader_by_name(Loader::DependencyLoader.new(loader, 'environment private', @module_resolver.all_module_loaders()))
+    loader = add_loader_by_name(Loader::DependencyLoader.new(loader, Loader::ENVIRONMENT_PRIVATE, @module_resolver.all_module_loaders()))
 
     # The module loader gets the private loader via a lazy operation to look up the module's private loader.
     # This does not work for an environment since it is not resolved the same way.

data/lib/puppet/pops/lookup/environment_data_provider.rb

@@ -17,7 +17,7 @@ class EnvironmentDataProvider < ConfiguredDataProvider
       if Puppet[:strict] == :error
         config.fail(Issues::HIERA_VERSION_3_NOT_GLOBAL, :where => 'environment')
       else
-        Puppet.warn_once(:hiera_v3_at_env_root, config.config_path, 'hiera.yaml version 3 found at the environment root was ignored')
+        Puppet.warn_once(:hiera_v3_at_env_root, config.config_path, _('hiera.yaml version 3 found at the environment root was ignored'), config.config_path)
       end
       nil
     end

data/lib/puppet/pops/lookup/hiera_config.rb

@@ -106,7 +106,9 @@ class HieraConfig
   def self.symkeys_to_string(struct)
     case(struct)
     when Hash
-      Hash[struct.map { |k,v| [k.to_s, symkeys_to_string(v)] }]
+      map = {}
+      struct.each_pair {|k,v| map[ k.is_a?(Symbol) ? k.to_s : k] = symkeys_to_string(v) }
+      map
     when Array
       struct.map { |v| symkeys_to_string(v) }
     else

data/lib/puppet/pops/lookup/interpolation.rb

@@ -57,10 +57,11 @@ module Interpolation
           # Alias is only permitted if the entire string is equal to the interpolate expression
           fail(Issues::HIERA_INTERPOLATION_ALIAS_NOT_ENTIRE_STRING) if is_alias && subject != match
           value = interpolate_method(method_key).call(key, lookup_invocation, subject)
-          value = lookup_invocation.check(method_key == :scope ? "scope:#{key}" : key) { interpolate(value, lookup_invocation, allow_methods) }
 
           # break gsub and return value immediately if this was an alias substitution. The value might be something other than a String
           return value if is_alias
+
+          value = lookup_invocation.check(method_key == :scope ? "scope:#{key}" : key) { interpolate(value, lookup_invocation, allow_methods) }
         end
         value.nil? ? '' : value
       end

data/lib/puppet/pops/lookup/lookup_key.rb

@@ -16,7 +16,7 @@ class LookupKey
     @key = key
     @module_name = qual_index.nil? ? nil : root_key[0..qual_index-1].freeze
     @root_key = root_key
-    @segments = segments.empty? ? nil : segments.map { |segment| segment =~ /^[0-9]+$/ ? segment.to_i : segment }.freeze
+    @segments = segments.empty? ? nil : segments.freeze
   end
 
   def dig(lookup_invocation, value)

data/lib/puppet/pops/lookup/module_data_provider.rb

@@ -60,8 +60,16 @@ class ModuleDataProvider < ConfiguredDataProvider
   protected
 
   def assert_config_version(config)
-    config.fail(Issues::HIERA_VERSION_3_NOT_GLOBAL, :where => 'module') unless config.version > 3
-    config
+    if config.version > 3
+      config
+    else
+      if Puppet[:strict] == :error
+        config.fail(Issues::HIERA_VERSION_3_NOT_GLOBAL, :where => 'module')
+      else
+        Puppet.warn_once(:hiera_v3_at_module_root, config.config_path, _('hiera.yaml version 3 found at module root was ignored'), config.config_path)
+      end
+      nil
+    end
   end
 
   # Return the root of the module with the name equal to the configured module name

data/lib/puppet/pops/lookup/sub_lookup.rb

@@ -30,7 +30,13 @@ module SubLookup
       raise yield('Syntax error') unless segments.size * 2 == count + 1
       segments.map! do |segment|
         segment.strip!
-        segment.start_with?('"') || segment.start_with?("'") ? segment[1..-2] : segment
+        if segment.start_with?('"') || segment.start_with?("'")
+          segment[1..-2]
+        elsif segment =~ /^(:?[+-]?[0-9]+)$/
+          segment.to_i
+        else
+          segment
+        end
       end
     else
       raise yield('Syntax error')
@@ -58,18 +64,13 @@ module SubLookup
             lookup_invocation.report_not_found(segment)
             throw :no_such_key
           end
-          if segment.is_a?(Integer) || segment =~ /^[0-9]+$/
-            segment = segment.to_i
-            unless value.instance_of?(Array)
-              raise Puppet::DataBinding::LookupError,
-                "Data Provider type mismatch: Got #{value.class.name} when Array was expected to access value using '#{segment}' from key '#{key}'"
-            end
-            unless segment < value.size
+          if segment.is_a?(Integer) && value.instance_of?(Array)
+            unless segment >= 0 && segment < value.size
               lookup_invocation.report_not_found(segment)
               throw :no_such_key
             end
           else
-            unless value.respond_to?(:'[]') && !(value.instance_of?(Array) || value.instance_of?(String))
+            unless value.respond_to?(:'[]') && !(value.is_a?(Array) || value.instance_of?(String))
               raise Puppet::DataBinding::LookupError,
                 "Data Provider type mismatch: Got #{value.class.name} when a hash-like object was expected to access value using '#{segment}' from key '#{key}'"
             end

data/lib/puppet/pops/parser/lexer2.rb

@@ -203,7 +203,7 @@ class Lexer2
   # PERFORMANCE NOTE:
   # Comparison against a frozen string is faster (than unfrozen).
   #
-  STRING_BSLASH_BSLASH = '\\'.freeze
+  STRING_BSLASH_SLASH = '\/'.freeze
 
   attr_reader :locator
 
@@ -376,8 +376,10 @@ class Lexer2
           # regexp position is a regexp, else a div
           if regexp_acceptable? && value = scn.scan(PATTERN_REGEX)
             # Ensure an escaped / was not matched
-            while value[-2..-2] == STRING_BSLASH_BSLASH # i.e. \\
-              value += scn.scan_until(PATTERN_REGEX_END)
+            while escaped_end(value)
+              more = scn.scan_until(PATTERN_REGEX_END)
+              return emit(TOKEN_DIV, before) unless more
+              value << more
             end
             regex = value.sub(PATTERN_REGEX_A, '').sub(PATTERN_REGEX_Z, '').gsub(PATTERN_REGEX_ESC, '/')
             emit_completed([:REGEX, Regexp.new(regex), scn.pos-before], before)
@@ -597,6 +599,21 @@ class Lexer2
     @selector.freeze
   end
 
+  # Determine if last char of value is escaped by a backslash
+  def escaped_end(value)
+    escaped = false
+    if value.end_with?(STRING_BSLASH_SLASH)
+      value[1...-1].each_codepoint do |cp|
+        if cp == 0x5c # backslash
+          escaped = !escaped
+        else
+          escaped = false
+        end
+      end
+    end
+    escaped
+  end
+
   # Clears the lexer state (it is not required to call this as it will be garbage collected
   # and the next lex call (lex_string, lex_file) will reset the internal state.
   #

data/lib/puppet/pops/pcore.rb

@@ -77,7 +77,7 @@ module Pcore
   end
 
   def self.add_type(type, loader, name_authority = RUNTIME_NAME_AUTHORITY)
-    loader.set_entry(Loader::TypedName.new(:type, type.name.downcase, name_authority), type)
+    loader.set_entry(Loader::TypedName.new(:type, type.name, name_authority), type)
     type
   end
 
@@ -90,7 +90,7 @@ module Pcore
       add_type(Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(type_string), nil), loader, name_authority)
     end
     parser = Types::TypeParser.singleton
-    aliases.each_key.map { |name| loader.load(:type, name.downcase).resolve(parser, loader) }
+    aliases.each_key.map { |name| loader.load(:type, name).resolve(parser, loader) }
   end
 end
 end