puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/lib/puppet/parser/templatewrapper.rb

@@ -78,7 +78,7 @@ class Puppet::Parser::TemplateWrapper
     # Expose all the variables in our scope as instance variables of the
     # current object, making it possible to access them without conflict
     # to the regular methods.
-    benchmark(:debug, "Bound template variables for #{template_source}") do
+    benchmark(:debug, _("Bound template variables for %{template_source}") % { template_source: template_source }) do
       scope.to_hash.each do |name, value|
         realname = name.gsub(/[^\w]/, "_")
         instance_variable_set("@#{realname}", value)
@@ -86,7 +86,7 @@ class Puppet::Parser::TemplateWrapper
     end
 
     result = nil
-    benchmark(:debug, "Interpolated template #{template_source}") do
+    benchmark(:debug, _("Interpolated template %{template_source}") % { template_source: template_source }) do
       template = ERB.new(string, 0, "-")
       template.filename = @__file__
       result = template.result(binding)

data/lib/puppet/parser/type_loader.rb

@@ -98,7 +98,7 @@ class Puppet::Parser::TypeLoader
   end
 
   def raise_no_files_found(pattern)
-    raise TypeLoaderError, "No file(s) found for import of '#{pattern}'"
+    raise TypeLoaderError, _("No file(s) found for import of '%{pattern}'") % { pattern: pattern }
   end
 
   def load_files(modname, files)

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.rb

@@ -10,10 +10,13 @@ module Puppet
   #
   # @api public
   module Pops
-     EMPTY_HASH = {}.freeze
+    EMPTY_HASH = {}.freeze
     EMPTY_ARRAY = [].freeze
     EMPTY_STRING = ''.freeze
 
+    MAX_INTEGER =  0x7fffffffffffffff
+    MIN_INTEGER = -0x8000000000000000
+
     DOUBLE_COLON = '::'.freeze
     USCORE = '_'.freeze
 
@@ -29,14 +32,11 @@ module Puppet
     require 'puppet/pops/visitable'
     require 'puppet/pops/visitor'
 
-    require 'puppet/pops/containment'
-
     require 'puppet/pops/issues'
     require 'puppet/pops/semantic_error'
     require 'puppet/pops/label_provider'
     require 'puppet/pops/validation'
     require 'puppet/pops/issue_reporter'
-    require 'puppet/pops/model/model'
 
     require 'puppet/pops/time/timespan'
     require 'puppet/pops/time/timestamp'
@@ -49,6 +49,7 @@ module Puppet
     require 'puppet/pops/merge_strategy'
 
     module Model
+      require 'puppet/pops/model/ast'
       require 'puppet/pops/model/tree_dumper'
       require 'puppet/pops/model/ast_transformer'
       require 'puppet/pops/model/factory'
@@ -56,37 +57,6 @@ module Puppet
       require 'puppet/pops/model/model_label_provider'
     end
 
-    module Binder
-      module SchemeHandler
-        # the handlers are auto loaded via bindings
-      end
-      module Producers
-        require 'puppet/pops/binder/producers'
-      end
-
-      require 'puppet/pops/binder/binder'
-      require 'puppet/pops/binder/bindings_model'
-      require 'puppet/pops/binder/binder_issues'
-      require 'puppet/pops/binder/bindings_checker'
-      require 'puppet/pops/binder/bindings_factory'
-      require 'puppet/pops/binder/bindings_label_provider'
-      require 'puppet/pops/binder/bindings_validator_factory'
-      require 'puppet/pops/binder/injector_entry'
-      require 'puppet/pops/binder/key_factory'
-      require 'puppet/pops/binder/injector'
-      require 'puppet/pops/binder/bindings_composer'
-      require 'puppet/pops/binder/bindings_model_dumper'
-      require 'puppet/pops/binder/system_bindings'
-      require 'puppet/pops/binder/bindings_loader'
-
-      module Config
-        require 'puppet/pops/binder/config/binder_config'
-        require 'puppet/pops/binder/config/binder_config_checker'
-        require 'puppet/pops/binder/config/issues'
-        require 'puppet/pops/binder/config/diagnostic_producer'
-      end
-    end
-
     module Resource
       require 'puppet/pops/resource/resource_type_impl'
     end
@@ -145,6 +115,6 @@ module Puppet
   require 'puppet/parser/ast/pops_bridge'
   require 'puppet/bindings'
   require 'puppet/functions'
-  require 'puppet/loaders'
+
+  Puppet::Pops::Model.register_pcore_types
 end
-require 'puppet/plugins/data_providers'

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
+  class EmptyAlternativeAdapter < Adaptable::Adapter
+    # @return [Object] The alternative value associated with an object
+    attr_accessor :empty_alternative
+  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)
+  # 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
 
-    # @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)
+    def initialize(object)
+      @object = object
     end
 
-    def offset
-      @adapted.offset
+    def file
+      @object.file
     end
 
-    def length
-      @adapted.length
-    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,7 +72,7 @@ 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)
         if loader_name.nil?
@@ -155,7 +101,7 @@ module Adapters
     # @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?
+      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) }
@@ -187,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