puppet 4.10.0 → 5.0.0

data/lib/puppet/plugins/configuration.rb

@@ -5,73 +5,21 @@
 #
 # @api private
 #
-require 'puppet/plugins'
-
-module Puppet::Plugins::Configuration
-    require 'puppet/plugins/binding_schemes'
+module Puppet::Plugins
+  module Configuration
     require 'puppet/plugins/syntax_checkers'
-    require 'puppet/plugins/data_providers'
-    require 'puppet/plugins/data_providers/registry'
-
-    # Extension-points are registered here:
-    #
-    # - If in a Ruby submodule it is best to create it here
-    # - The class does not have to be required; it will be auto required when the binder
-    #   needs it.
-    # - If the extension is a multibind, it can be registered here; either with a required
-    #   class or a class reference in string form.
-
-    checkers_name = Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_KEY
-    checkers_type = Puppet::Plugins::SyntaxCheckers::SYNTAX_CHECKERS_TYPE
-
-    schemes_name = Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_KEY
-    schemes_type = Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_TYPE
-
-    # Register extension points
-    # -------------------------
-    system_bindings = ::Puppet::Pops::Binder::SystemBindings
-    extensions = system_bindings.extensions()
-
-    extensions.multibind(checkers_name).name(checkers_name).hash_of(checkers_type)
-    extensions.multibind(schemes_name).name(schemes_name).hash_of(schemes_type)
-    Puppet::Plugins::DataProviders::Registry.register_extensions(extensions)
-
-    # Register injector boot bindings
-    # -------------------------------
-    boot_bindings = system_bindings.injector_boot_bindings()
-
-    # Register the default bindings scheme handlers
-    { 'module'        => 'ModuleScheme', 
-      'confdir'       => 'ConfdirScheme',
-    }.each do |scheme, class_name|
-      boot_bindings \
-        .bind.name(scheme) \
-        .instance_of(schemes_type) \
-        .in_multibind(schemes_name) \
-        .to_instance("Puppet::Pops::Binder::SchemeHandler::#{class_name}")
-    end
-
-    # Default extensions delivered in Puppet Core are included here
-    # -------------------------------------------------------------
-    # Classes in this name-space are lazily loaded as they may be overridden and/or never used
-    # (Lazy loading is done by binding to the name of a class instead of a Class instance).
-
-    # Register extensions
-    # -------------------
-    bindings = system_bindings.default_bindings()
-    bindings.bind do
-      name('json')
-      instance_of(checkers_type)
-      in_multibind(checkers_name)
-      to_instance('Puppet::SyntaxCheckers::Json')
+    require 'puppet/syntax_checkers/base64'
+    require 'puppet/syntax_checkers/json'
+
+    def self.load_plugins
+      # Register extensions
+      # -------------------
+      {
+        SyntaxCheckers::SYNTAX_CHECKERS_KEY => {
+          'json' => Puppet::SyntaxCheckers::Json.new,
+          'base64' => Puppet::SyntaxCheckers::Base64.new
+        }
+      }
     end
-
-    bindings.bind do
-      name('base64')
-      instance_of(checkers_type)
-      in_multibind(checkers_name)
-      to_instance('Puppet::SyntaxCheckers::Base64')
-    end
-
-    Puppet::Plugins::DataProviders::Registry.register_defaults(bindings)
+  end
 end

data/lib/puppet/plugins/syntax_checkers.rb

@@ -1,18 +1,13 @@
-require 'puppet/plugins'
-module Puppet::Plugins::SyntaxCheckers
-  # The lookup **key** for the multibind containing syntax checkers used to syntax check embedded string in non
-  # puppet DSL syntax.
-  # @api public
-  SYNTAX_CHECKERS_KEY       = 'puppet::syntaxcheckers'
+module Puppet::Plugins
+module SyntaxCheckers
 
-  # The lookup **type** for the multibind containing syntax checkers used to syntax check embedded string in non
+  # The lookup **key** for the multibind containing syntax checkers used to syntax check embedded string in non
   # puppet DSL syntax.
   # @api public
-  SYNTAX_CHECKERS_TYPE  = 'Puppet::Plugins::SyntaxCheckers::SyntaxChecker'
+  SYNTAX_CHECKERS_KEY = :'puppet::syntaxcheckers'
 
   # SyntaxChecker is a Puppet Extension Point for the purpose of extending Puppet with syntax checkers.
-  # The intended use is to create a class derived from this class and then register it with the
-  # Puppet Binder.
+  # The intended use is to create a class derived from this class and then register it with the Puppet context
   #
   # Creating the Extension Class
   # ----------------------------
@@ -99,5 +94,5 @@ module Puppet::Plugins::SyntaxCheckers
       raise NotImplementedError, "The class #{self.class.name} should have implemented the method check()"
     end
   end
-
+end
 end

data/lib/puppet/pops/adaptable.rb

@@ -171,8 +171,7 @@ module Adaptable
     # @return [adapter] the given adapter
     #
     def self.associate_adapter(adapter, o)
-      attr_name = :"@#{instance_var_name(adapter.class.name)}"
-      o.instance_variable_set(attr_name, adapter)
+      o.instance_variable_set(self_attr_name, adapter)
       adapter
     end
 
@@ -187,13 +186,19 @@ module Adaptable
       name.split(DOUBLE_COLON).join(USCORE)
     end
 
+    # Returns the name of the class, or the name of the type if the class represents an Object type
+    # @return [String] the name of the class or type
+    def self.type_name
+      self.name
+    end
+
     # Returns a suitable instance variable name for the _name_ of this instance. The name is created by calling
     # Adapter#instance_var_name and then cached.
     # @return [String] the instance variable name for _name_
     # @api private
     #
     def self.self_attr_name
-      @attr_name_sym ||= :"@#{instance_var_name(self.name)}"
+      @attr_name_sym ||= :"@#{instance_var_name(type_name)}"
     end
   end
 end

data/lib/puppet/pops/adapters.rb

@@ -11,96 +11,42 @@ module Adapters
     attr_accessor :documentation
   end
 
-  # A SourcePosAdapter holds a reference to  a *Positioned* object (object that has offset and length).
-  # This somewhat complex structure makes it possible to correctly refer to a source position
-  # in source that is embedded in some resource; a parser only sees the embedded snippet of source text
-  # and does not know where it was embedded. It also enables lazy evaluation of source positions (they are
-  # rarely needed - typically just when there is an error to report.
+  # An  empty alternative adapter is used when there is the need to
+  # attach a value to be used if the original is empty. This is used
+  # when a lazy evaluation takes place, and the decision how to handle an
+  # empty case must be delayed.
   #
-  # @note It is relatively expensive to compute line and position on line - it is not something that
-  #   should be done for every token or model object.
-  #
-  # @see Utils#find_adapter, Utils#find_closest_positioned
-  #
-  class SourcePosAdapter < Adaptable::Adapter
-    attr_accessor :locator
-    attr_reader :adapted
-
-    def self.create_adapter(o)
-      new(o)
-    end
-
-    def initialize(o)
-      @adapted = o
-    end
-
-    def locator
-      # The locator is always the parent locator, all positioned objects are positioned within their
-      # parent. If a positioned object also has a locator that locator is for its children!
-      #
-      @locator ||= self.class.find_locator(@adapted.eContainer)
-    end
+  class EmptyAlternativeAdapter < Adaptable::Adapter
+    # @return [Object] The alternative value associated with an object
+    attr_accessor :empty_alternative
+  end
 
-    # @api private
-    def self.find_locator(o)
-      raise ArgumentError, 'InternalError: SourcePosAdapter for something that has no locator among parents' if o.nil?
-      found_locator = o.respond_to?(:locator) ? o.locator : nil
-      return found_locator unless found_locator.nil?
-      adapter = get(o)
-      return adapter.locator unless adapter.nil?
-      container = o.eContainer
-      container.nil? ? nil : find_locator(container)
+  # This class is for backward compatibility only. It's not really an adapter but it is
+  # needed for the puppetlabs-strings gem
+  # @deprecated
+  class SourcePosAdapter
+    def self.adapt(object)
+      new(object)
     end
 
-    def offset
-      @adapted.offset
+    def initialize(object)
+      @object = object
     end
 
-    def length
-      @adapted.length
+    def file
+      @object.file
     end
 
-    # Produces the line number for the given offset.
-    # @note This is an expensive operation
-    #
     def line
-      locator.line_for_offset(offset)
+      @object.line
     end
 
-    # Produces the position on the line of the given offset.
-    # @note This is an expensive operation
-    #
     def pos
-      locator.pos_on_line(offset)
+      @object.pos
     end
 
-    # Extracts the text represented by this source position (the string is obtained from the locator)
     def extract_text
-      locator.extract_text(offset, length)
-    end
-
-    def extract_tree_text
-      first = @adapted.offset
-      last = first + @adapted.length
-      @adapted.eAllContents.each do |m|
-        m_offset = m.offset
-        next if m_offset.nil?
-        first = m_offset if m_offset < first
-        m_last = m_offset + m.length
-        last = m_last if m_last > last
-      end
-      locator.extract_text(first, last-first)
-    end
-
-    # Produces an URI with path?line=n&pos=n. If origin is unknown the URI is string:?line=n&pos=n
-    def to_uri
-      f = locator.file
-      if f.nil? || f.empty?
-        f = 'string:'
-      else
-        f = Puppet::Util.path_to_uri(f).to_s
-      end
-      URI("#{f}?line=#{line.to_s}&pos=#{pos.to_s}")
+      @object.locator.extract_text(@object.offset, @object.length)
     end
   end
 
@@ -126,10 +72,14 @@ module Adapters
     def self.loader_for_model_object(model, file = nil, default_loader = nil)
       loaders = Puppet.lookup(:loaders) { nil }
       if loaders.nil?
-        default_loader
+        default_loader || Loaders.static_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 +95,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?
+      file = instance.file 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 ||= {}
@@ -181,12 +133,6 @@ module Adapters
       end
       nil
     end
-
-    # @api private
-    def self.find_file(instance)
-      source_pos = Utils.find_closest_positioned(instance)
-      source_pos.nil? ? nil : source_pos.locator.file
-    end
   end
 end
 end

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

@@ -268,7 +268,7 @@ class AccessOperator
     expected = expected_classes.map {|c| label_provider.label(c) }.join(' or ')
     fail(Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[key_index], {
       :type => type,
-      :message => "Cannot use #{bad_key_type_name(actual)} where #{expected} is expected"
+      :message => _("Cannot use %{key} where %{expected} is expected") % { key: bad_key_type_name(actual), expected: expected }
     })
   end
 
@@ -616,6 +616,8 @@ class AccessOperator
     return result_type_array ? result : result.pop
   end
 
+  NS = '::'.freeze
+
   def access_PHostClassType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
     keys_orig_size = keys.size
@@ -642,30 +644,14 @@ class AccessOperator
     end
 
     if o.class_name.nil?
-      # The type argument may be a Resource Type - the Puppet Language allows a reference such as
-      # Class[Foo], and this is interpreted as Class[Resource[Foo]] - which is ok as long as the resource
-      # does not have a title. This should probably be deprecated.
-      #
       result = keys.each_with_index.map do |c, i|
-        name = if c.is_a?(Types::PResourceType) && !c.type_name.nil? && c.title.nil?
-                 strict_check(c, i)
-                 # type_name is already downcase. Don't waste time trying to downcase again
-                 c.type_name
-               elsif c.is_a?(String)
-                 c.downcase
-               elsif c.is_a?(Types::PTypeReferenceType)
-                 strict_check(c, i)
-                 c.type_string.downcase
-               else
-                 fail(Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
-               end
-
-        if name =~ Patterns::NAME
-          # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
-          Types::PHostClassType.new(name.sub(/^::/, EMPTY_STRING))
-        else
-          fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})
-        end
+        fail(Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c}) unless c.is_a?(String)
+        name = c.downcase
+        # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
+        name = name[2..-1] if name[0,2] == NS
+
+        fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c}) unless name =~ Patterns::NAME
+        Types::PHostClassType.new(name)
       end
     else
       # lookup class resource and return one or more parameter values
@@ -687,21 +673,6 @@ class AccessOperator
     # returns single type as type, else an array of types
     return result_type_array ? result : result.pop
   end
-
-  # PUP-6083 - Using Class[Foo] is deprecated since an arbitrary foo will trigger a "resource not found"
-  # @api private
-  def strict_check(name, index)
-    if Puppet[:strict] != :off
-      msg = 'Upper cased class-name in a Class[<class-name>] is deprecated, class-name should be a lowercase string'
-      case Puppet[:strict]
-      when :error
-        fail(Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[index], {:name => name})
-      when :warning
-        Puppet.warn_once(:deprecation, 'ClassReferenceInUpperCase', msg)
-      end
-    end
-  end
-
 end
 end
 end

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

@@ -23,16 +23,11 @@ class CollectorTransformer
 
     fail "Resource type #{type} doesn't exist" unless resource_type
 
-    adapter = Adapters::SourcePosAdapter.adapt(o)
-    line_num = adapter.line
-    position = adapter.pos
-    file_path = adapter.locator.file
-
     if !o.operations.empty?
       overrides = {
         :parameters => o.operations.map{ |x| @@evaluator.evaluate(x, scope)}.flatten,
-        :file       => file_path,
-        :line       => [line_num, position],
+        :file       => o.file,
+        :line       => [o.line, o.pos],
         :source     => scope.source,
         :scope      => scope
       }
@@ -42,10 +37,10 @@ class CollectorTransformer
 
     case o.query
     when Model::VirtualQuery
-      newcoll = Collectors::CatalogCollector.new(scope, resource_type.name, code, overrides)
+      newcoll = Collectors::CatalogCollector.new(scope, resource_type, code, overrides)
     when Model::ExportedQuery
       match = match_unless_nop(o.query, scope)
-      newcoll = Collectors::ExportedCollector.new(scope, resource_type.name, match, code, overrides)
+      newcoll = Collectors::ExportedCollector.new(scope, resource_type, match, code, overrides)
     end
 
     scope.compiler.add_collection(newcoll)
@@ -96,7 +91,7 @@ protected
     right_code = query(o.right_expr, scope)
 
     case o.operator
-    when :'=='
+    when '=='
       if left_code == "tag"
         # Ensure that to_s and downcase is done once, i.e. outside the proc block and
         # then use raw_tagged? instead of tagged?
@@ -106,7 +101,7 @@ protected
           tags = [ right_code ]
         end
         tags = tags.collect do |t|
-          raise ArgumentError, 'Cannot transform a number to a tag' if t.is_a?(Numeric)
+          raise ArgumentError, _('Cannot transform a number to a tag') if t.is_a?(Numeric)
           t.to_s.downcase
         end
         proc do |resource|
@@ -121,7 +116,7 @@ protected
           end
         end
       end
-    when :'!='
+    when '!='
       proc do |resource|
         !@@compare_operator.equals(resource[left_code], right_code)
       end
@@ -169,7 +164,7 @@ protected
   end
 
   def query_Object(o, scope)
-    raise ArgumentError, "Cannot transform object of class #{o.class}"
+    raise ArgumentError, _("Cannot transform object of class %{klass}") % { klass: o.class }
   end
 
   def match_AccessExpression(o, scope)
@@ -231,7 +226,7 @@ protected
   end
 
   def match_Object(o, scope)
-    raise ArgumentError, "Cannot transform object of class #{o.class}"
+    raise ArgumentError, _("Cannot transform object of class %{klass}") % { klass: o.class }
   end
 end
 end

data/lib/puppet/pops/evaluator/collectors/catalog_collector.rb

@@ -3,14 +3,14 @@ class Puppet::Pops::Evaluator::Collectors::CatalogCollector < Puppet::Pops::Eval
   # Creates a CatalogCollector using the AbstractCollector's 
   # constructor to set the scope and overrides
   #
-  # param [Symbol] type the resource type to be collected
+  # param [Puppet::CompilableResourceType] type the resource type to be collected
   # param [Proc] query the query which defines which resources to match
   def initialize(scope, type, query, overrides = nil)
     super(scope, overrides)
 
     @query = query
 
-    @type = Puppet::Resource.new(type, "whatever").type
+    @type = Puppet::Resource.new(type, 'whatever').type
   end
 
   # Collects virtual resources based off a collection in a manifest

data/lib/puppet/pops/evaluator/collectors/exported_collector.rb

@@ -3,7 +3,7 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
   # Creates an ExportedCollector using the AbstractCollector's
   # constructor to set the scope and overrides
   #
-  # param [Symbol] type the resource type to be collected
+  # param [Puppet::CompilableResourceType] type the resource type to be collected
   # param [Array] equery an array representation of the query (exported query)
   # param [Proc] cquery a proc representation of the query (catalog query)
   def initialize(scope, type, equery, cquery, overrides = nil)
@@ -12,7 +12,7 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
     @equery = equery
     @cquery = cquery
 
-    @type = Puppet::Resource.new(type, "whatever").type
+    @type = Puppet::Resource.new(type, 'whatever').type
   end
 
   # Ensures that storeconfigs is present before calling AbstractCollector's
@@ -47,7 +47,7 @@ class Puppet::Pops::Evaluator::Collectors::ExportedCollector < Puppet::Pops::Eva
         if existing = @scope.findresource(item.resource_type, item.title)
           unless existing.collector_id == item.collector_id
             raise Puppet::ParseError,
-              "A duplicate resource was found while collecting exported resources, with the type and title #{item.ref}"
+              _("A duplicate resource was found while collecting exported resources, with the type and title %{title}") % { title: item.ref }
           end
         else
           item.exported = false

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

@@ -47,7 +47,7 @@ class CompareOperator
 
   def cmp_String(a, b)
     return a.casecmp(b) if b.is_a?(String)
-    raise ArgumentError.new("A String is not comparable to a non String")
+    raise ArgumentError.new(_("A String is not comparable to a non String"))
   end
 
   # Equality is case independent.
@@ -60,7 +60,7 @@ class CompareOperator
     if b.is_a?(Numeric)
       a <=> b
     else
-      raise ArgumentError.new("A Numeric is not comparable to non Numeric")
+      raise ArgumentError.new(_("A Numeric is not comparable to non Numeric"))
     end
   end
 
@@ -88,27 +88,27 @@ class CompareOperator
     if b.is_a?(Symbol)
       a <=> b
     else
-      raise ArgumentError.new("Symbol not comparable to non Symbol")
+      raise ArgumentError.new(_("Symbol not comparable to non Symbol"))
     end
   end
 
   def cmp_Timespan(a, b)
-    raise ArgumentError.new('Timespans are only comparable to Timespans, Integers, and Floats') unless b.is_a?(Time::Timespan) ||  b.is_a?(Integer) || b.is_a?(Float)
+    raise ArgumentError.new(_('Timespans are only comparable to Timespans, Integers, and Floats')) unless b.is_a?(Time::Timespan) ||  b.is_a?(Integer) || b.is_a?(Float)
     a <=> b
   end
 
   def cmp_Timestamp(a, b)
-    raise ArgumentError.new('Timestamps are only comparable to Timestamps, Integers, and Floats') unless b.is_a?(Time::Timestamp) ||  b.is_a?(Integer) || b.is_a?(Float)
+    raise ArgumentError.new(_('Timestamps are only comparable to Timestamps, Integers, and Floats')) unless b.is_a?(Time::Timestamp) ||  b.is_a?(Integer) || b.is_a?(Float)
     a <=> b
   end
 
   def cmp_Version(a, b)
-    raise ArgumentError.new('Versions not comparable to non Versions') unless b.is_a?(SemanticPuppet::Version)
+    raise ArgumentError.new(_('Versions not comparable to non Versions')) unless b.is_a?(SemanticPuppet::Version)
     a <=> b
   end
 
   def cmp_Object(a, b)
-    raise ArgumentError.new('Only Strings, Numbers, Timespans, Timestamps, and Versions are comparable')
+    raise ArgumentError.new(_('Only Strings, Numbers, Timespans, Timestamps, and Versions are comparable'))
   end
 
 

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

@@ -33,7 +33,7 @@ class Puppet::Pops::Evaluator::EppEvaluator
     scope.debug "Retrieving epp template #{file}"
     template_file = Puppet::Parser::Files.find_template(file, env_name)
     if template_file.nil? ||  !Puppet::FileSystem.exist?(template_file)
-      raise Puppet::ParseError, "Could not find template '#{file}'"
+      raise Puppet::ParseError, _("Could not find template '%{file}'") % { file: file }
     end
 
     # Parse and validate the source