puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

data/lib/puppet/plugins/data_providers/registry.rb

@@ -0,0 +1,84 @@
+module Puppet::Plugins::DataProviders
+  class Registry
+    def self.register_extensions(extensions)
+      extensions.multibind(PER_MODULE_DATA_PROVIDER_KEY).name(PER_MODULE_DATA_PROVIDER_KEY).hash_of(PER_MODULE_DATA_PROVIDER_TYPE)
+      extensions.multibind(ENV_DATA_PROVIDERS_KEY).name(ENV_DATA_PROVIDERS_KEY).hash_of(ENV_DATA_PROVIDERS_TYPE)
+      extensions.multibind(MODULE_DATA_PROVIDERS_KEY).name(MODULE_DATA_PROVIDERS_KEY).hash_of(MODULE_DATA_PROVIDERS_TYPE)
+      extensions.multibind(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY).name(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY).hash_of(PATH_BASED_DATA_PROVIDER_FACTORIES_TYPE)
+    end
+
+    def self.hash_of_per_module_data_provider
+      @@HASH_OF_PER_MODULE_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(PER_MODULE_DATA_PROVIDER_TYPE)
+    end
+
+    def self.hash_of_module_data_providers
+      @@HASH_OF_MODULE_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(
+        Puppet::Pops::Types::TypeFactory.type_of(MODULE_DATA_PROVIDERS_TYPE))
+    end
+
+    def self.hash_of_environment_data_providers
+      @@HASH_OF_ENV_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(
+        Puppet::Pops::Types::TypeFactory.type_of(ENV_DATA_PROVIDERS_TYPE))
+    end
+
+    def self.hash_of_path_based_data_provider_factories
+      @@HASH_OF_PATH_BASED_DATA_PROVIDER_FACTORIES ||= Puppet::Pops::Types::TypeFactory.hash_of(
+        Puppet::Pops::Types::TypeFactory.type_of(PATH_BASED_DATA_PROVIDER_FACTORIES_TYPE))
+    end
+
+    # Registers a 'none' environment data provider, and a 'none' module data provider as the defaults.
+    # This is only done to allow that something binds to 'none' rather than removing the entire binding (which
+    # has the same effect).
+    #
+    def self.register_defaults(default_bindings)
+      default_bindings.bind do
+        name('none')
+        in_multibind(ENV_DATA_PROVIDERS_KEY)
+        to_instance(ENV_DATA_PROVIDERS_TYPE)
+      end
+
+      default_bindings.bind do
+        name('function')
+        in_multibind(ENV_DATA_PROVIDERS_KEY)
+        to_instance('Puppet::DataProviders::FunctionEnvDataProvider')
+      end
+
+      default_bindings.bind do
+        name('hiera')
+        in_multibind(ENV_DATA_PROVIDERS_KEY)
+        to_instance('Puppet::DataProviders::HieraEnvDataProvider')
+      end
+
+      default_bindings.bind do
+        name('none')
+        in_multibind(MODULE_DATA_PROVIDERS_KEY)
+        to_instance(MODULE_DATA_PROVIDERS_TYPE)
+      end
+
+      default_bindings.bind do
+        name('function')
+        in_multibind(MODULE_DATA_PROVIDERS_KEY)
+        to_instance('Puppet::DataProviders::FunctionModuleDataProvider')
+      end
+
+      default_bindings.bind do
+        name('hiera')
+        in_multibind(MODULE_DATA_PROVIDERS_KEY)
+        to_instance('Puppet::DataProviders::HieraModuleDataProvider')
+      end
+
+      default_bindings.bind do
+        name('json')
+        in_multibind(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY)
+        to_instance('Puppet::DataProviders::JsonDataProviderFactory')
+      end
+
+      default_bindings.bind do
+        name('yaml')
+        in_multibind(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY)
+        to_instance('Puppet::DataProviders::YamlDataProviderFactory')
+      end
+    end
+  end
+end
+

data/lib/puppet/pops.rb

@@ -27,6 +27,8 @@ module Puppet
     require 'puppet/pops/validation'
     require 'puppet/pops/issue_reporter'
     require 'puppet/pops/lookup'
+    require 'puppet/pops/lookup/invocation'
+    require 'puppet/pops/lookup/explainer'
 
     require 'puppet/pops/model/model'
 
@@ -39,6 +41,7 @@ module Puppet
     require 'puppet/pops/types/type_parser'
     require 'puppet/pops/types/class_loader'
     require 'puppet/pops/types/enumeration'
+    require 'puppet/pops/types/type_mismatch_describer'
 
     require 'puppet/pops/merge_strategy'
 
@@ -81,29 +84,12 @@ module Puppet
       end
     end
 
-    module Parser
-      require 'puppet/pops/parser/eparser'
-      require 'puppet/pops/parser/parser_support'
-      require 'puppet/pops/parser/locator'
-      require 'puppet/pops/parser/locatable'
-      require 'puppet/pops/parser/lexer2'
-      require 'puppet/pops/parser/evaluating_parser'
-      require 'puppet/pops/parser/epp_parser'
-      require 'puppet/pops/parser/code_merger'
-    end
-
-    module Validation
-      require 'puppet/pops/validation/checker4_0'
-      require 'puppet/pops/validation/validator_factory_4_0'
-    end
-
     module Evaluator
       require 'puppet/pops/evaluator/callable_signature'
       require 'puppet/pops/evaluator/runtime3_converter'
       require 'puppet/pops/evaluator/runtime3_support'
       require 'puppet/pops/evaluator/evaluator_impl'
       require 'puppet/pops/evaluator/epp_evaluator'
-      require 'puppet/pops/evaluator/callable_mismatch_describer'
       require 'puppet/pops/evaluator/collector_transformer'
       require 'puppet/pops/evaluator/puppet_proc'
       module Collectors
@@ -114,6 +100,22 @@ module Puppet
       end
     end
 
+    module Parser
+      require 'puppet/pops/parser/eparser'
+      require 'puppet/pops/parser/parser_support'
+      require 'puppet/pops/parser/locator'
+      require 'puppet/pops/parser/locatable'
+      require 'puppet/pops/parser/lexer2'
+      require 'puppet/pops/parser/evaluating_parser'
+      require 'puppet/pops/parser/epp_parser'
+      require 'puppet/pops/parser/code_merger'
+    end
+
+    module Validation
+      require 'puppet/pops/validation/checker4_0'
+      require 'puppet/pops/validation/validator_factory_4_0'
+    end
+
     # Subsystem for puppet functions defined in ruby.
     #
     # @api public

data/lib/puppet/pops/adapters.rb

@@ -85,6 +85,18 @@ module Puppet::Pops::Adapters
       locator.string.slice(offset, length)
     end
 
+    def extract_tree_text
+      first = @adapted.offset
+      last = first + @adapted.length
+      @adapted.eAllContents.each do |m|
+        m_offset = m.offset
+        first = m_offset if m_offset < first
+        m_last = m_offset + m.length
+        last = m_last if m_last > last
+      end
+      locator.string.slice(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

data/lib/puppet/pops/binder/binder.rb

@@ -138,7 +138,7 @@ class Puppet::Pops::Binder::Binder
 
   # @api private
   def self.format_binding(b)
-    type_name = Puppet::Pops::Types::TypeCalculator.new().string(b.type)
+    type_name = Puppet::Pops::Types::TypeCalculator.singleton.string(b.type)
     layer_name, bindings_name = get_named_binding_layer_and_name(b)
     "binding: '#{type_name}/#{b.name}' in: '#{bindings_name}' in layer: '#{layer_name}'"
   end
@@ -319,7 +319,7 @@ class Puppet::Pops::Binder::Binder
           unless key_factory.is_contributions_key?(k)
             if v.is_abstract?()
               layer_name, bindings_name = Puppet::Pops::Binder::Binder.get_named_binding_layer_and_name(v.binding)
-              type_name = key_factory.type_calculator.string(v.binding.type)
+              type_name = Puppet::Pops::Types::TypeCalculator.singleton.string(v.binding.type)
               raise ArgumentError, "The abstract binding '#{type_name}/#{v.binding.name}' in '#{bindings_name}' in layer '#{layer_name}' was not overridden"
             end
             raise ArgumentError, "Internal Error - redefinition of key: #{k}, (should never happen)" if entry

data/lib/puppet/pops/binder/bindings_checker.rb

@@ -12,7 +12,7 @@ class Puppet::Pops::Binder::BindingsChecker
   # @api public
   def initialize(diagnostics_producer)
     @@check_visitor     ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
-    @type_calculator      = Puppet::Pops::Types::TypeCalculator.new()
+    @type_calculator      = Puppet::Pops::Types::TypeCalculator.singleton
     @expression_validator = Puppet::Pops::Validation::ValidatorFactory_4_0.new().checker(diagnostics_producer)
     @acceptor             = diagnostics_producer
   end

data/lib/puppet/pops/binder/bindings_label_provider.rb

@@ -1,7 +1,9 @@
 # A provider of labels for bindings model object, producing a human name for the model object.
 # @api private
 #
-class Puppet::Pops::Binder::BindingsLabelProvider < Puppet::Pops::LabelProvider
+class Puppet::Pops::Binder::BindingsLabelProvider
+  include Puppet::Pops::LabelProvider
+
   def initialize
     @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
   end

data/lib/puppet/pops/binder/bindings_loader.rb

@@ -38,11 +38,10 @@ class Puppet::Pops::Binder::BindingsLoader
     paths_for_name(name).find {|p| Puppet::FileSystem.exist?(File.join(basedir, "lib/puppet/bindings", p)+'.rb') }
   end
 
-  private
-
   def self.loader()
     @autoloader ||= Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings")
   end
+  private_class_method :loader
 
   def self.provide_from_string(scope, name)
     name_path = name.split('::')
@@ -52,6 +51,7 @@ class Puppet::Pops::Binder::BindingsLoader
     end
     provide_from_name_path(scope, name, name_path)
   end
+  private_class_method :provide_from_string
 
   def self.provide_from_name_path(scope, name, name_path)
     # If bindings is already loaded, try this first
@@ -64,14 +64,17 @@ class Puppet::Pops::Binder::BindingsLoader
     end
     result
   end
+  private_class_method :provide_from_name_path
 
   def self.paths_for_name(fq_name)
     [de_camel(fq_name), downcased_path(fq_name)].uniq
   end
+  private_class_method :paths_for_name
 
   def self.downcased_path(fq_name)
     fq_name.to_s.gsub(/::/, '/').downcase
   end
+  private_class_method :downcased_path
 
   def self.de_camel(fq_name)
     fq_name.to_s.gsub(/::/, '/').
@@ -80,4 +83,5 @@ class Puppet::Pops::Binder::BindingsLoader
     tr("-", "_").
     downcase
   end
+  private_class_method :de_camel
 end

data/lib/puppet/pops/binder/bindings_model_meta.rb

@@ -94,7 +94,7 @@ module Puppet::Pops::Binder::Bindings
   # @api public
   #
   class LookupProducerDescriptor < ProducerDescriptor
-    contains_one_uni 'type', Puppet::Pops::Types::PAnyType
+    has_attr 'type', Object
     has_attr 'name', String
   end
 
@@ -147,7 +147,7 @@ module Puppet::Pops::Binder::Bindings
   #
   # @api public
   class Binding < AbstractBinding
-    contains_one_uni 'type', Puppet::Pops::Types::PAnyType
+    has_attr 'type', Object
     has_attr 'name', String
     has_attr 'override', Boolean
     has_attr 'abstract', Boolean

data/lib/puppet/pops/binder/config/binder_config.rb

@@ -23,7 +23,7 @@ module Puppet::Pops::Binder::Config
 
     DEFAULT_LAYERS = [
       { 'name' => 'site',    'include' => [ 'confdir:/default?optional'] },
-      { 'name' => 'modules', 'include' => [ 'module:/*::default'] },
+      { 'name' => 'modules', 'include' => [ 'module:/*::default', 'module:/*::metadata'] },
     ]
 
     DEFAULT_SCHEME_EXTENSIONS = {}

data/lib/puppet/pops/binder/injector.rb

@@ -354,7 +354,7 @@ module Private
     def initialize
       @entries = []
       @key_factory = Puppet::Pops::Binder::KeyFactory.new()
-      @type_calculator = @key_factory.type_calculator
+      @type_calculator = Puppet::Pops::Types::TypeCalculator.singleton
     end
 
     def lookup(scope, *args, &block)
@@ -430,7 +430,7 @@ module Private
       # represented the same (but still opaque) way.
       #
       @key_factory         = configured_binder.key_factory()
-      @type_calculator     = key_factory.type_calculator()
+      @type_calculator     = Puppet::Pops::Types::TypeCalculator.singleton
       @@transform_visitor ||= Puppet::Pops::Visitor.new(nil,"transform", 2,  2)
       @recursion_lock = [ ]
     end
@@ -484,7 +484,7 @@ module Private
     def lookup_type(scope, type, name='')
       val = lookup_key(scope, named_key(type, name))
       return nil if val.nil?
-      unless key_factory.type_calculator.instance?(type, val)
+      unless type_calculator.instance?(type, val)
         raise ArgumentError, "Type error: incompatible type, #{type_error_detail(type, val)}"
       end
       val
@@ -510,7 +510,7 @@ module Private
         when Puppet::Pops::Binder::InjectorEntry
           val = produce(scope, entry)
           return nil if val.nil?
-          unless key_factory.type_calculator.instance?(entry.binding.type, val)
+          unless type_calculator.instance?(entry.binding.type, val)
             raise "Type error: incompatible type returned by producer, #{type_error_detail(entry.binding.type, val)}"
           end
           val

data/lib/puppet/pops/binder/key_factory.rb

@@ -3,12 +3,6 @@
 #
 class Puppet::Pops::Binder::KeyFactory
 
-  attr_reader :type_calculator
-  # @api public
-  def initialize(type_calculator = Puppet::Pops::Types::TypeCalculator.new())
-    @type_calculator = type_calculator
-  end
-
   # @api public
   def binding_key(binding)
     named_key(binding.type, binding.name)
@@ -16,12 +10,12 @@ class Puppet::Pops::Binder::KeyFactory
 
   # @api public
   def named_key(type, name)
-    [(@type_calculator.assignable?(@type_calculator.data, type) ? @type_calculator.data : type), name]
+    [(Puppet::Pops::Types::PDataType::DEFAULT.assignable?(type) ? Puppet::Pops::Types::PDataType::DEFAULT : type), name]
   end
 
   # @api public
   def data_key(name)
-    [@type_calculator.data, name]
+    [Puppet::Pops::Types::PDataType::DEFAULT, name]
   end
 
   # @api public
@@ -49,7 +43,7 @@ class Puppet::Pops::Binder::KeyFactory
   # @api public
   def is_data?(key)
     return false unless key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PAnyType)
-    type_calculator.assignable?(type_calculator.data(), key[0])
+    Puppet::Pops::Types::PDataType::DEFAULT.assignable?(key[0])
   end
 
   # @api public

data/lib/puppet/pops/binder/scheme_handler/module_scheme.rb

@@ -15,7 +15,18 @@ require 'puppet/pops/binder/scheme_handler/symbolic_scheme'
 #   Does currently only support checking of optionality against files under a module. If the result should be loaded
 #   from any other location it can not be marked as optional as it will be ignored.
 #
-class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::SchemeHandler::SymbolicScheme
+module Puppet::Pops::Binder
+class SchemeHandler::ModuleScheme < SchemeHandler::SymbolicScheme
+
+  METADATA_DATA_PROVIDER = 'data_provider'.freeze
+
+  def contributed_bindings(uri, scope, composer)
+    split_name, fqn = fqn_from_path(uri)
+    bindings = Puppet::Bindings.resolve(scope, split_name[0]) || load_bindings(uri, scope, composer, split_name, fqn)
+
+    # Must clone as the rest mutates the model
+    BindingsFactory.contributed_bindings(fqn, Marshal.load(Marshal.dump(bindings)))
+  end
 
   # Expands URIs with wildcards and checks optionality.
   # @param uri [URI] the uri to possibly expand
@@ -29,13 +40,18 @@ class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::
     # supports wild card in the module name
     case split_name[0]
     when '*'
-      # create new URIs, one per module name that has a corresponding .rb file relative to its
-      # '<root>/lib/puppet/bindings/'
+      # create new URIs, one per module name that has a corresponding data_provider entry in metadata.json
+      # or an .rb file relative to its '<root>/lib/puppet/bindings/'
       #
-      composer.name_to_module.each_pair do | mod_name, mod |
-        expanded_name_parts = [mod_name] + split_name[1..-1]
+      composer.name_to_module.each_pair do | module_name, mod |
+        expanded_name_parts = [module_name] + split_name[1..-1]
         expanded_name = expanded_name_parts.join('::')
-        if Puppet::Pops::Binder::BindingsLoader.loadable?(mod.path, expanded_name)
+
+        if is_metadata?(split_name)
+          if mod.metadata && mod.metadata[METADATA_DATA_PROVIDER]
+            result << URI.parse('module:/' + expanded_name)
+          end
+        elsif BindingsLoader.loadable?(mod.path, expanded_name)
           result << URI.parse('module:/' + expanded_name)
         end
       end
@@ -43,11 +59,18 @@ class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::
       raise ArgumentError, "Bad bindings uri, the #{uri} has neither module name or wildcard '*' in its first path position"
     else
       joined_name = split_name.join('::')
+      module_name = split_name[0]
       # skip optional uri if it does not exist
       if is_optional?(uri)
-        mod = composer.name_to_module[split_name[0]]
-        if mod && Puppet::Binder::BindingsLoader.loadable?(mod.path, joined_name)
-          result << URI.parse('module:/' + joined_name)
+        mod = composer.name_to_module[module_name]
+        unless mod.nil?
+          if is_metadata?(split_name)
+            if mod.metadata && mod.metadata[METADATA_DATA_PROVIDER]
+              result << URI.parse('module:/' + joined_name)
+            end
+          elsif BindingsLoader.loadable?(mod.path, joined_name)
+            result << URI.parse('module:/' + joined_name)
+          end
         end
       else
         # assume it exists (do not give error if not, since it may be excluded later)
@@ -81,4 +104,40 @@ class Puppet::Pops::Binder::SchemeHandler::ModuleScheme < Puppet::Pops::Binder::
     end
     result
   end
+
+  def load_bindings(uri, scope, composer, split_name, fqn)
+    module_name = split_name[0]
+    mod = composer.name_to_module[module_name]
+    # given module name must exist
+    raise ArgumentError, "Cannot load bindings '#{uri}' - module not found." if mod.nil?
+
+    if is_metadata?(split_name)
+      metadata = mod.metadata
+      data_provider = metadata.nil? ? nil : metadata[METADATA_DATA_PROVIDER]
+      unless data_provider.nil?
+        # bind the data provider in a binding named after the module
+        # loader.load('thallgren/sample_module_data', Puppet.lookup(:current_environment))
+        Puppet::Bindings.newbindings(module_name) do
+          bind {
+            name(module_name)
+            to(data_provider)
+            in_multibind(Puppet::Plugins::DataProviders::PER_MODULE_DATA_PROVIDER_KEY)
+          }
+        end
+        # pick up and return the just created and registered bindings
+        bindings = Puppet::Bindings.resolve(scope, module_name)
+      end
+    else
+      bindings = BindingsLoader.provide(scope, fqn)
+    end
+    raise ArgumentError, "Cannot load bindings '#{uri}' - no bindings found." unless bindings
+    bindings
+  end
+  private :load_bindings
+
+  def is_metadata?(split_name)
+    split_name.size > 1 && split_name[1] == 'metadata'
+  end
+  private :is_metadata?
+end
 end