puppet 3.2.4 → 3.3.0.rc2

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

@@ -0,0 +1,142 @@
+# @api public
+module Puppet::Pops::Binder::BinderIssues
+
+  # NOTE: The methods #issue and #hard_issue are done in a somewhat funny way
+  # since the Puppet::Pops::Issues is a module with these methods defined on the module-class
+  # This makes it hard to inherit them in this module. (Likewise if Issues was a class, and they
+  # need to be defined for the class, and such methods are also not inherited, it becomes more
+  # difficult to reuse these. It did not seem as a good idea to refactor Issues at this point
+  # in time - they should both probably be refactored once bindings support is finished.
+  # Meanwhile, they delegate to Issues.
+
+
+  # (see Puppet::Pops::Issues#issue)
+  def self.issue (issue_code, *args, &block)
+    Puppet::Pops::Issues.issue(issue_code, *args, &block)
+  end
+
+  # (see Puppet::Pops::Issues#hard_issue)
+  def self.hard_issue(issue_code, *args, &block)
+    Puppet::Pops::Issues.hard_issue(issue_code, *args, &block)
+  end
+
+  # Producer issues (binding identified using :binding argument)
+
+  # @api public
+  MISSING_NAME = issue :MISSING_NAME, :binding do
+    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no name"
+  end
+
+  # @api public
+  MISSING_KEY = issue :MISSING_KEY, :binding do
+    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no key"
+  end
+
+  # @api public
+  MISSING_VALUE = issue :MISSING_VALUE, :binding do
+    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no value"
+  end
+
+  # @api public
+  MISSING_EXPRESSION = issue :MISSING_EXPRESSION, :binding do
+    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no expression"
+  end
+
+  # @api public
+  MISSING_CLASS_NAME = issue :MISSING_CLASS_NAME, :binding do
+    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no class name"
+  end
+
+  # @api public
+  CACHED_PRODUCER_MISSING_PRODUCER = issue :PRODUCER_MISSING_PRODUCER, :binding do
+    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no producer"
+  end
+
+  # @api public
+  INCOMPATIBLE_TYPE = issue :INCOMPATIBLE_TYPE, :binding, :expected_type, :actual_type do
+    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has an incompatible type: expected #{label.a_an(expected_type)}, but got #{label.a_an(actual_type)}."
+  end
+
+  # @api public
+  MULTIBIND_INCOMPATIBLE_TYPE = issue :MULTIBIND_INCOMPATIBLE_TYPE, :binding, :actual_type do
+    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} cannot bind #{label.a_an(actual_type)} value"
+  end
+
+  # @api public
+  MODEL_OBJECT_IS_UNBOUND = issue :MODEL_OBJECT_IS_UNBOUND do
+    "#{label.a_an_uc(semantic)} is not contained in a binding"
+  end
+
+  # Binding issues (binding identified using semantic)
+
+  # @api public
+  MISSING_PRODUCER = issue :MISSING_PRODUCER do
+    "#{label.a_an_uc(semantic)} has no producer"
+  end
+
+  # @api public
+  MISSING_TYPE = issue :MISSING_TYPE do
+    "#{label.a_an_uc(semantic)} has no type"
+  end
+
+  # @api public
+  MULTIBIND_NOT_COLLECTION_PRODUCER = issue :MULTIBIND_NOT_COLLECTION_PRODUCER, :actual_producer do
+    "#{label.a_an_uc(semantic)} must have a MultibindProducerDescriptor, but got: #{label.a_an(actual_producer)}"
+  end
+
+  # @api public
+  MULTIBIND_TYPE_ERROR = issue :MULTIBIND_TYPE_ERROR, :actual_type do
+    "#{label.a_an_uc(semantic)} is expected to bind a collection type, but got: #{label.a_an(actual_type)}."
+  end
+
+  # @api public
+  MISSING_BINDINGS = issue :MISSING_BINDINGS do
+    "#{label.a_an_uc(semantic)} has zero bindings"
+  end
+
+  # @api public
+  MISSING_BINDINGS_NAME = issue :MISSING_BINDINGS_NAME do
+    "#{label.a_an_uc(semantic)} has no name"
+  end
+
+  # @api public
+  MISSING_PREDICATES = issue :MISSING_PREDICATES do
+    "#{label.a_an_uc(semantic)} has zero predicates"
+  end
+
+  # @api public
+  MISSING_CATEGORIZATION = issue :MISSING_CATEGORIZATION do
+    "#{label.a_an_uc(semantic)} has a category without categorization"
+  end
+
+  # @api public
+  MISSING_CATEGORY_VALUE = issue :MISSING_CATEGORY_VALUE do
+    "#{label.a_an_uc(semantic)} has a category without value"
+  end
+
+  # @api public
+  MISSING_LAYERS = issue :MISSING_LAYERS do
+    "#{label.a_an_uc(semantic)} has zero layers"
+  end
+
+  # @api public
+  MISSING_LAYER_NAME = issue :MISSING_LAYER_NAME do
+    "#{label.a_an_uc(semantic)} has a layer without name"
+  end
+
+  # @api public
+  MISSING_BINDINGS_IN_LAYER = issue :MISSING_BINDINGS_IN_LAYER, :layer do
+    "#{label.a_an_uc(semantic)} has zero bindings in #{label.label(layer)}"
+  end
+
+  # @api public
+  PRECEDENCE_MISMATCH_IN_CONTRIBUTION = issue :PRECEDENCE_MISMATCH_IN_CONTRIBUTION, :categorization do
+    "Precedence mismatch: binding contribution '#{semantic.name}', category: '#{categorization}' is not in correct order"
+  end
+
+  # @api public
+  MISSING_CATEGORY_PRECEDENCE = issue :MISSING_CATEGORY_PRECEDENCE, :categorization do
+    "Missing category precedence: binding contribution '#{semantic.name}', category: '#{categorization}' not found in overall config"
+  end
+
+end

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

@@ -0,0 +1,217 @@
+# A validator/checker of a bindings model
+# @api public
+#
+class Puppet::Pops::Binder::BindingsChecker
+  Bindings = Puppet::Pops::Binder::Bindings
+  Issues = Puppet::Pops::Binder::BinderIssues
+  Types = Puppet::Pops::Types
+
+  attr_reader :type_calculator
+  attr_reader :acceptor
+
+  # @api public
+  def initialize(diagnostics_producer)
+    @@check_visitor     ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
+    @type_calculator      = Puppet::Pops::Types::TypeCalculator.new()
+    @expression_validator = Puppet::Pops::Validation::ValidatorFactory_3_1.new().checker(diagnostics_producer)
+    @acceptor             = diagnostics_producer
+  end
+
+  # Validates the entire model by visiting each model element and calling `check`.
+  # The result is collected (or acted on immediately) by the configured diagnostic provider/acceptor
+  # given when creating this Checker.
+  #
+  # @api public
+  #
+  def validate(b)
+    check(b)
+    b.eAllContents.each {|c| check(c) }
+  end
+
+  # Performs binding validity check
+  # @api private
+  def check(b)
+    @@check_visitor.visit_this(self, b)
+  end
+
+  # Checks that a binding has a producer and a type
+  # @api private
+  def check_Binding(b)
+    # Must have a type
+    acceptor.accept(Issues::MISSING_TYPE, b) unless b.type.is_a?(Types::PObjectType)
+
+    # Must have a producer
+    acceptor.accept(Issues::MISSING_PRODUCER, b) unless b.producer.is_a?(Bindings::ProducerDescriptor)
+  end
+
+  # Checks that the producer is a Multibind producer and that the type is a PCollectionType
+  # @api private
+  def check_Multibinding(b)
+    # id is optional (empty id blocks contributions)
+
+    # A multibinding must have PCollectionType
+    acceptor.accept(Issues::MULTIBIND_TYPE_ERROR, b, {:actual_type => b.type})  unless b.type.is_a?(Types::PCollectionType)
+
+    # if the producer is nil, a suitable producer will be picked automatically
+    unless b.producer.nil? || b.producer.is_a?(Bindings::MultibindProducerDescriptor)
+      acceptor.accept(Issues::MULTIBIND_NOT_COLLECTION_PRODUCER, b, {:actual_producer => b.producer})
+    end
+  end
+
+  # Checks that the bindings object contains at least one binding. Then checks each binding in turn
+  # @api private
+  def check_Bindings(b)
+    acceptor.accept(Issues::MISSING_BINDINGS, b) unless has_entries?(b.bindings)
+  end
+
+  # Checks that a name has been associated with the bindings
+  # @api private
+  def check_NamedBindings(b)
+    acceptor.accept(Issues::MISSING_BINDINGS_NAME, b) unless has_chars?(b.name)
+    check_Bindings(b)
+  end
+
+  # Check that the category has a categorization and a value
+  # @api private
+  def check_Category(c)
+    acceptor.accept(Issues::MISSING_CATEGORIZATION, binding_parent(c)) unless has_chars?(c.categorization)
+    acceptor.accept(Issues::MISSING_CATEGORY_VALUE, binding_parent(c)) unless has_chars?(c.value)
+  end
+
+  # Check that the binding contains at least one predicate and that all predicates are categorized and has a value
+  # @api private
+  def check_CategorizedBindings(b)
+    acceptor.accept(Issues::MISSING_PREDICATES, b) unless has_entries?(b.predicates)
+    check_Bindings(b)
+  end
+
+  # @api private
+  def check_EffectiveCategories(ec)
+  end
+
+  # Check layer has a name
+  # @api private
+  def check_NamedLayer(l)
+    acceptor.accept(Issues::MISSING_LAYER_NAME, binding_parent(l)) unless has_chars?(l.name)
+# It is ok to have an empty layer
+#    acceptor.accept(Issues::MISSING_BINDINGS_IN_LAYER, binding_parent(l), { :layer => l.name }) unless has_entries?(l.bindings)
+  end
+
+  # Checks that the binding has layers and that each layer has a name and at least one binding
+  # @api private
+  def check_LayeredBindings(b)
+    acceptor.accept(Issues::MISSING_LAYERS, b) unless has_entries?(b.layers)
+  end
+
+  # Checks that the non caching producer has a producer to delegate to
+  # @api private
+  def check_NonCachingProducerDescriptor(p)
+    acceptor.accept(Issues::PRODUCER_MISSING_PRODUCER, p) unless p.producer.is_a?(Bindings::ProducerDescriptor)
+  end
+
+  # Checks that a constant value has been declared in the producer and that the type
+  # of the value is compatible with the type declared in the binding
+  # @api private
+  def check_ConstantProducerDescriptor(p)
+    # the product must be of compatible type
+    # TODO: Likely to change when value becomes a typed Puppet Object
+    b = binding_parent(p)
+    if p.value.nil?
+      acceptor.accept(Issues::MISSING_VALUE, p, {:binding => b})
+    else
+      infered = type_calculator.infer(p.value)
+      unless type_calculator.assignable?(b.type, infered)
+        acceptor.accept(Issues::INCOMPATIBLE_TYPE, p, {:binding => b, :expected_type => b.type, :actual_type => infered})
+      end
+    end
+  end
+
+  # Checks that an expression has been declared in the producer
+  # @api private
+  def check_EvaluatingProducerDescriptor(p)
+    unless p.expression.is_a?(Puppet::Pops::Model::Expression)
+      acceptor.accept(Issues::MISSING_EXPRESSION, p, {:binding => binding_parent(p)})
+    end
+  end
+
+  # Checks that a class name has been declared in the producer
+  # @api private
+  def check_InstanceProducerDescriptor(p)
+    acceptor.accept(Issues::MISSING_CLASS_NAME, p, {:binding => binding_parent(p)}) unless has_chars?(p.class_name)
+  end
+
+  # Checks that a type and a name has been declared. The type must be assignable to the type
+  # declared in the binding. The name can be an empty string to denote 'no name'
+  # @api private
+  def check_LookupProducerDescriptor(p)
+    b = binding_parent(p)
+    unless type_calculator.assignable(b.type, p.type)
+      acceptor.accept(Issues::INCOMPATIBLE_TYPE, p, {:binding => b, :expected_type => b.type, :actual_type => p.type })
+    end
+    acceptor.accept(Issues::MISSING_NAME, p, {:binding => b}) if p.name.nil? # empty string is OK
+  end
+
+  # Checks that a key has been declared, then calls producer_LookupProducerDescriptor to perform
+  # checks associated with the super class
+  # @api private
+  def check_HashLookupProducerDescriptor(p)
+    acceptor.accept(Issues::MISSING_KEY, p, {:binding => binding_parent(p)}) unless has_chars?(p.key)
+    check_LookupProducerDescriptor(p)
+  end
+
+  # Checks that the type declared in the binder is a PArrayType
+  # @api private
+  def check_ArrayMultibindProducerDescriptor(p)
+    b = binding_parent(p)
+    acceptor.accept(Issues::MULTIBIND_INCOMPATIBLE_TYPE, p, {:binding => b, :actual_type => b.type}) unless b.type.is_a?(Types::PArrayType)
+  end
+
+  # Checks that the type declared in the binder is a PHashType
+  # @api private
+  def check_HashMultibindProducerDescriptor(p)
+    b = binding_parent(p)
+    acceptor.accept(Issues::MULTIBIND_INCOMPATIBLE_TYPE, p, {:binding => b, :actual_type => b.type}) unless b.type.is_a?(Types::PHashType)
+  end
+
+  # Checks that the producer that this producer delegates to is declared
+  # @api private
+  def check_ProducerProducerDescriptor(p)
+    unless p.producer.is_a?(Bindings::ProducerDescriptor)
+      acceptor.accept(Issues::PRODUCER_MISSING_PRODUCER, p, {:binding => binding_parent(p)})
+    end
+  end
+
+  # @api private
+  def check_Expression(t)
+    @expression_validator.validate(t)
+  end
+
+  # @api private
+  def check_PObjectType(t)
+    # Do nothing
+  end
+
+  # Returns true if the argument is a non empty string
+  # @api private
+  def has_chars?(s)
+    s.is_a?(String) && !s.empty?
+  end
+
+  # @api private
+  def has_entries?(s)
+    !(s.nil? || s.empty?)
+  end
+
+  # @api private
+  def binding_parent(p)
+    begin
+      x = p.eContainer
+      if x.nil?
+        acceptor.accept(Issues::MODEL_OBJECT_IS_UNBOUND, p)
+        return nil
+      end
+      p = x
+    end while !p.is_a?(Bindings::AbstractBinding)
+    p
+  end
+end

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

@@ -0,0 +1,241 @@
+# The BindingsComposer handles composition of multiple bindings sources
+# It is directed by a {Puppet::Pops::Binder::Config::BinderConfig BinderConfig} that indicates how
+# the final composition should be layered, and what should be included/excluded in each layer
+#
+# The bindings composer is intended to be used once per environment as the compiler starts its work.
+#
+# TODO: Possibly support envdir: scheme / relative to environment root (== same as confdir if there is only one environment).
+#       This is probably easier to do after ENC changes described in ARM-8 have been implemented.
+# TODO: If same config is loaded in a higher layer, skip it in the lower (since it is meaningless to load it again with lower
+#       precedence. (Optimization, or possibly an error, should produce a warning).
+#
+class Puppet::Pops::Binder::BindingsComposer
+
+  # The BindingsConfig instance holding the read and parsed, but not evaluated configuration
+  # @api public
+  #
+  attr_reader :config
+
+  # map of scheme name to handler
+  # @api private
+  attr_reader :scheme_handlers
+
+  # @return Hash<String, Puppet::Module> map of module name to module instance
+  # @api private
+  attr_reader :name_to_module
+
+  # @api private
+  attr_reader :confdir
+
+  # @api private
+  attr_reader :diagnostics
+
+  # Container of all warnings and errors produced while initializing and loading bindings
+  #
+  # @api public
+  attr_reader :acceptor
+
+  # @api public
+  def initialize()
+    @acceptor = Puppet::Pops::Validation::Acceptor.new()
+    @diagnostics = Puppet::Pops::Binder::Config::DiagnosticProducer.new(acceptor)
+    @config = Puppet::Pops::Binder::Config::BinderConfig.new(@diagnostics)
+    if acceptor.errors?
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, :message => 'Binding Composer: error while reading config.')
+      raise Puppet::DevError.new("Internal Error: IssueReporter did not raise exception for errors in bindings config.")
+    end
+  end
+
+  # Configures and creates the boot injector.
+  # The read config may optionally contain mapping of bindings scheme handler name to handler class, and
+  # mapping of biera2 backend symbolic name to backend class.
+  # If present, these are turned into bindings in the category 'extension' (which is only used in the boot injector) which
+  # has higher precedence than 'default'. This is done to allow users to override the default bindings for
+  # schemes and backends.
+  # @param scope [Puppet::Parser:Scope] the scope (used to find compiler and injector for the environment)
+  # @api private
+  #
+  def configure_and_create_injector(scope)
+    # create the injector (which will pick up the bindings registered above)
+    @scheme_handlers = SchemeHandlerHelper.new(scope)
+
+    # get extensions from the config
+    # ------------------------------
+    scheme_extensions = @config.scheme_extensions
+    hiera_backends = @config.hiera_backends
+
+    # Define a named bindings that are known by the SystemBindings
+    boot_bindings = Puppet::Pops::Binder::BindingsFactory.named_bindings(Puppet::Pops::Binder::SystemBindings::ENVIRONMENT_BOOT_BINDINGS_NAME) do
+      scheme_extensions.each_pair do |scheme, class_name|
+        # turn each scheme => class_name into a binding (contribute to the buildings-schemes multibind).
+        # do this in category 'extensions' to allow them to override the 'default'
+        when_in_category('extension', 'true').bind do
+          name(scheme)
+          instance_of(Puppetx::BINDINGS_SCHEMES_TYPE)
+          in_multibind(Puppetx::BINDINGS_SCHEMES)
+          to_instance(class_name)
+          end
+      end
+      hiera_backends.each_pair do |symbolic, class_name|
+        # turn each symbolic => class_name into a binding (contribute to the hiera backends multibind).
+        # do this in category 'extensions' to allow them to override the 'default'
+        when_in_category('extension', 'true').bind do
+          name(symbolic)
+          instance_of(Puppetx::HIERA2_BACKENDS_TYPE)
+          in_multibind(Puppetx::HIERA2_BACKENDS)
+          to_instance(class_name)
+        end
+      end
+    end
+
+    @injector = scope.compiler.create_boot_injector(boot_bindings.model)
+  end
+
+  # @return [Puppet::Pops::Binder::Bindings::LayeredBindings]
+  def compose(scope)
+    # The boot injector is used to lookup scheme-handlers
+    configure_and_create_injector(scope)
+
+    # get all existing modules and their root path
+    @name_to_module = {}
+    scope.environment.modules.each {|mod| name_to_module[mod.name] = mod }
+
+    # setup the confdir
+    @confdir = Puppet.settings[:confdir]
+
+    factory = Puppet::Pops::Binder::BindingsFactory
+    contributions = []
+    configured_layers = @config.layering_config.collect do |  layer_config |
+      # get contributions with effective categories
+      contribs = configure_layer(layer_config, scope, diagnostics)
+      # collect the contributions separately for later checking of category precedence
+      contributions.concat(contribs)
+      # create a named layer with all the bindings for this layer
+      factory.named_layer(layer_config['name'], *contribs.collect {|c| c.bindings }.flatten)
+    end
+
+    # must check all contributions are based on compatible category precedence
+    # (Note that contributions no longer contains the bindings as a side effect of setting them in the collected
+    # layer. The effective categories and the name remains in the contributed model; this is enough for checking
+    # and error reporting).
+    check_contribution_precedence(contributions)
+
+    # Add the two system layers; the final - highest ("can not be overridden" layer), and the lowest
+    # Everything here can be overridden 'default' layer.
+    #
+    configured_layers.insert(0, Puppet::Pops::Binder::SystemBindings.final_contribution)
+    configured_layers.insert(-1, Puppet::Pops::Binder::SystemBindings.default_contribution)
+
+    # and finally... create the resulting structure
+    factory.layered_bindings(*configured_layers)
+  end
+
+  # Evaluates configured categorization and returns the result.
+  # The result is not cached.
+  # @api public
+  #
+  def effective_categories(scope)
+    unevaluated_categories = @config.categorization
+    parser = Puppet::Pops::Parser::EvaluatingParser.new()
+    file_source = @config.config_file or "defaults in: #{__FILE__}"
+    evaluated_categories = unevaluated_categories.collect do |category_tuple|
+      evaluated_categories = [ category_tuple[0], parser.evaluate_string( scope, parser.quote( category_tuple[1] ), file_source ) ]
+      if evaluated_categories[1].is_a?(String)
+        # category values are always in lower case
+        evaluated_categories[1] = evaluated_categories[1].downcase
+      else
+        raise ArgumentError, "Categorization value must be a string, category #{evaluated_categories[0]} evaluation resulted in a: '#{result[1].class}'"
+      end
+      evaluated_categories
+    end
+    Puppet::Pops::Binder::BindingsFactory::categories(evaluated_categories)
+  end
+
+  private
+
+  # Checks that contribution's effective categorization is in the same relative order as in the overall
+  # categorization precedence.
+  #
+  def check_contribution_precedence(contributions)
+    cat_prec = { }
+    @config.categorization.each_with_index {|c, i| cat_prec[ c[0] ] = i }
+    contributions.each() do |contrib|
+      # Contributions that do not specify their opinion about categorization silently accepts the precedence
+      # set in the root configuration - and may thus produce an unexpected result
+      #
+      next unless ec = contrib.effective_categories
+      next unless categories = ec.categories
+      prev_prec = -1
+      categories.each do |c|
+        prec = cat_prec[c.categorization]
+        issues = Puppet::Pops::Binder::BinderIssues
+        unless prec
+          diagnostics.accept(issues::MISSING_CATEGORY_PRECEDENCE, c, :categorization => c.categorization)
+          next
+        end
+        unless prec > prev_prec
+          diagnostics.accept(issues::PRECEDENCE_MISMATCH_IN_CONTRIBUTION, c, :categorization => c.categorization)
+        end
+        prev_prec = prec
+      end
+    end
+  end
+
+  def configure_layer(layer_description, scope, diagnostics)
+    name = layer_description['name']
+
+    # compute effective set of uris to load (and get rid of any duplicates in the process
+    included_uris = array_of_uris(layer_description['include'])
+    excluded_uris = array_of_uris(layer_description['exclude'])
+    effective_uris = Set.new(expand_included_uris(included_uris)).subtract(Set.new(expand_excluded_uris(excluded_uris)))
+
+    # Each URI should result in a ContributedBindings
+    effective_uris.collect { |uri| scheme_handlers[uri.scheme].contributed_bindings(uri, scope, self) }
+  end
+
+  def array_of_uris(descriptions)
+    return [] unless descriptions
+    descriptions = [descriptions] unless descriptions.is_a?(Array)
+    descriptions.collect {|d| URI.parse(d) }
+  end
+
+  def expand_included_uris(uris)
+    result = []
+    uris.each do |uri|
+      unless handler = scheme_handlers[uri.scheme]
+        raise ArgumentError, "Unknown bindings provider scheme: '#{uri.scheme}'"
+      end
+      result.concat(handler.expand_included(uri, self))
+    end
+    result
+  end
+
+  def expand_excluded_uris(uris)
+    result = []
+    uris.each do |uri|
+      unless handler = scheme_handlers[uri.scheme]
+        raise ArgumentError, "Unknown bindings provider scheme: '#{uri.scheme}'"
+      end
+      result.concat(handler.expand_excluded(uri, self))
+    end
+    result
+  end
+
+  class SchemeHandlerHelper
+    T = Puppet::Pops::Types::TypeFactory
+    HASH_OF_HANDLER = T.hash_of(T.type_of('Puppetx::Puppet::BindingsSchemeHandler'))
+    def initialize(scope)
+      @scope = scope
+      @cache = nil
+    end
+    def [] (scheme)
+      load_schemes unless @cache
+      @cache[scheme]
+    end
+
+    def load_schemes
+      @cache = @scope.compiler.boot_injector.lookup(@scope, HASH_OF_HANDLER, Puppetx::BINDINGS_SCHEMES) || {}
+    end
+  end
+
+end