puppet-retrospec 1.5.0 → 1.6.0

data/vendor/gems/puppet-4.5.2/lib/puppet/pops/lookup/interpolation.rb

@@ -1,115 +0,0 @@
-require_relative 'sub_lookup'
-
-# Add support for Hiera-like interpolation expressions. The expressions may contain keys that uses dot-notation
-# to further navigate into hashes and arrays
-#
-module Puppet::Pops
-module Lookup
-module Interpolation
-  include SubLookup
-
-  def interpolate(subject, lookup_invocation, allow_methods)
-    case subject
-    when String
-      subject.index('%{').nil? ? subject : interpolate_string(subject, lookup_invocation, allow_methods)
-    when Array
-      subject.map { |element| interpolate(element, lookup_invocation, allow_methods) }
-    when Hash
-      Hash[subject.map { |k, v| [k, interpolate(v, lookup_invocation, allow_methods)] }]
-    else
-      subject
-    end
-  end
-
-  private
-
-  EMPTY_INTERPOLATIONS = {
-    '' => true,
-    '::' => true,
-    '""' => true,
-    "''" => true,
-    '"::"' => true,
-    "'::'" => true
-  }.freeze
-
-  # Matches a key that is quoted using a matching pair of either single or double quotes.
-  QUOTED_KEY = /^(?:"([^"]+)"|'([^']+)')$/
-
-  def interpolate_string(subject, lookup_invocation, allow_methods)
-    lookup_invocation.with(:interpolate, subject) do
-      subject.gsub(/%\{([^\}]*)\}/) do |match|
-        expr = $1
-        # Leading and trailing spaces inside an interpolation expression are insignificant
-        expr.strip!
-        value = nil
-        unless EMPTY_INTERPOLATIONS[expr]
-          method_key, key = get_method_and_data(expr, allow_methods)
-          is_alias = method_key == 'alias'
-
-          # Alias is only permitted if the entire string is equal to the interpolate expression
-          raise Puppet::DataBinding::LookupError, "'alias' interpolation is only permitted if the expression is equal to the entire string" if is_alias && subject != match
-
-          segments = split_key(key) { |problem| Puppet::DataBinding::LookupError.new("#{problem} in string: #{subject}") }
-          root_key = segments.shift
-          value = interpolate_method(method_key).call(root_key, lookup_invocation)
-          value = sub_lookup(key, lookup_invocation, segments, value) unless segments.empty?
-          value = lookup_invocation.check(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
-        end
-        value || ''
-      end
-    end
-  end
-
-  def interpolate_method(method_key)
-    @@interpolate_methods ||= begin
-      global_lookup = lambda { |key, lookup_invocation| Lookup.lookup(key, nil, '', true, nil, lookup_invocation) }
-      scope_lookup = lambda do |key, lookup_invocation|
-        lookup_invocation.with(:scope, nil) do
-          ovr = lookup_invocation.override_values
-          if ovr.include?(key)
-            lookup_invocation.report_found_in_overrides(key, ovr[key])
-          else
-            scope = lookup_invocation.scope
-            if scope.include?(key)
-              lookup_invocation.report_found(key, scope[key])
-            else
-              defaults = lookup_invocation.default_values
-              if defaults.include?(key)
-                lookup_invocation.report_found_in_defaults(key, defaults[key])
-              else
-                nil
-              end
-            end
-          end
-        end
-      end
-
-      {
-        'lookup' => global_lookup,
-        'hiera' => global_lookup, # this is just an alias for 'lookup'
-        'alias' => global_lookup, # same as 'lookup' but expression must be entire string and result is not subject to string substitution
-        'scope' => scope_lookup,
-        'literal' => lambda { |key, _| key }
-      }.freeze
-    end
-    interpolate_method = @@interpolate_methods[method_key]
-    raise Puppet::DataBinding::LookupError, "Unknown interpolation method '#{method_key}'" unless interpolate_method
-    interpolate_method
-  end
-
-  def get_method_and_data(data, allow_methods)
-    if match = data.match(/^(\w+)\((?:["]([^"]+)["]|[']([^']+)['])\)$/)
-      raise Puppet::DataBinding::LookupError, 'Interpolation using method syntax is not allowed in this context' unless allow_methods
-      key = match[1]
-      data = match[2] || match[3] # double or single qouted
-    else
-      key = 'scope'
-    end
-    [key, data]
-  end
-end
-end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/pops/lookup/invocation.rb

@@ -1,119 +0,0 @@
-module Puppet::Pops::Lookup
-  class Invocation
-    attr_reader :scope, :override_values, :default_values, :explainer
-    attr_accessor :module_name, :top_key
-
-    # Creates a context object for a lookup invocation. The object contains the current scope, overrides, and default
-    # values and may optionally contain an {ExplanationAcceptor} instance that will receive book-keeping information
-    # about the progress of the lookup.
-    #
-    # If the _explain_ argument is a boolean, then _false_ means that no explanation is needed and _true_ means that
-    # the default explanation acceptor should be used. The _explain_ argument may also be an instance of the
-    # `ExplanationAcceptor` class.
-    #
-    # @param scope [Puppet::Parser::Scope] The scope to use for the lookup
-    # @param override_values [Hash<String,Object>|nil] A map to use as override. Values found here are returned immediately (no merge)
-    # @param default_values [Hash<String,Object>] A map to use as the last resort (but before default)
-    # @param explainer [boolean,Explanainer] An boolean true to use the default explanation acceptor or an explainer instance that will receive information about the lookup
-    def initialize(scope, override_values = {}, default_values = {}, explainer = nil)
-      @name_stack = []
-      @scope = scope
-      @override_values = override_values
-      @default_values = default_values
-      unless explainer.is_a?(Explainer)
-        explainer = explainer == true ? Explainer.new : nil
-      end
-      @explainer = explainer
-    end
-
-    def check(name)
-      if @name_stack.include?(name)
-        raise Puppet::DataBinding::RecursiveLookupError, "Recursive lookup detected in [#{@name_stack.join(', ')}]"
-      end
-      return unless block_given?
-
-      @name_stack.push(name)
-      begin
-        yield
-      rescue Puppet::DataBinding::LookupError
-        raise
-      rescue Puppet::Error => detail
-        raise Puppet::DataBinding::LookupError.new(detail.message, detail)
-      ensure
-        @name_stack.pop
-      end
-    end
-
-    # The qualifier_type can be one of:
-    # :global - qualifier is the data binding terminus name
-    # :data_provider - qualifier a DataProvider instance
-    # :path - qualifier is a ResolvedPath instance
-    # :merge - qualifier is a MergeStrategy instance
-    # :module - qualifier is the name of a module
-    # :interpolation - qualifier is the unresolved interpolation expression
-    # :meta - qualifier is the module name
-    # :data - qualifier is the key
-    #
-    # @param qualifier [Object] A branch, a provider, or a path
-    def with(qualifier_type, qualifier)
-      if @explainer.nil?
-        yield
-      else
-        @explainer.push(qualifier_type, qualifier)
-        begin
-          yield
-        ensure
-          @explainer.pop
-        end
-      end
-    end
-
-    def only_explain_options?
-      @explainer.nil? ? false : @explainer.only_explain_options?
-    end
-
-    def explain_options?
-      @explainer.nil? ? false : @explainer.explain_options?
-    end
-
-    def report_found_in_overrides(key, value)
-      @explainer.accept_found_in_overrides(key, value) unless @explainer.nil?
-      value
-    end
-
-    def report_found_in_defaults(key, value)
-      @explainer.accept_found_in_defaults(key, value) unless @explainer.nil?
-      value
-    end
-
-    def report_found(key, value)
-      @explainer.accept_found(key, value) unless @explainer.nil?
-      value
-    end
-
-    def report_merge_source(merge_source)
-      @explainer.accept_merge_source(merge_source) unless @explainer.nil?
-    end
-
-    # Report the result of a merge or fully resolved interpolated string
-    # @param value [Object] The result to report
-    # @return [Object] the given value
-    def report_result(value)
-      @explainer.accept_result(value) unless @explainer.nil?
-      value
-    end
-
-    def report_not_found(key)
-      @explainer.accept_not_found(key) unless @explainer.nil?
-    end
-
-    def report_path_not_found
-      @explainer.accept_path_not_found unless @explainer.nil?
-    end
-
-    def report_module_not_found
-      @explainer.accept_module_not_found unless @explainer.nil?
-    end
-  end
-end
-

data/vendor/gems/puppet-4.5.2/lib/puppet/pops/lookup/sub_lookup.rb

@@ -1,86 +0,0 @@
-module Puppet::Pops
-module Lookup
-module SubLookup
-  # Split key into segments. A segment may be a quoted string (both single and double quotes can
-  # be used) and the segment separator is the '.' character. Whitespace will be trimmed off on
-  # both sides of each segment. Whitespace within quotes are not trimmed.
-  #
-  # If the key cannot be parsed, this method will yield a string describing the problem to a one
-  # parameter block. The block must return an exception instance.
-  #
-  # @param key [String] the string to split
-  # @return Array<String> the array of segments
-  # @yieldparam problem [String] the problem, i.e. 'Syntax error'
-  # @yieldreturn [Exception] the exception to raise
-  #
-  # @api public
-  def split_key(key)
-    segments = key.split(/(\s*"[^"]+"\s*|\s*'[^']+'\s*|[^'".]+)/)
-    if segments.empty?
-      # Only happens if the original key was an empty string
-      ''
-    elsif segments.shift == ''
-      count = segments.size
-      raise yield('Syntax error') unless count > 0
-
-      segments.keep_if { |seg| seg != '.' }
-      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
-      end
-    else
-      raise yield('Syntax error')
-    end
-  end
-
-  # Perform a sub-lookup using the given _segments_ to access the given _value_. Each segment must be a string. A string
-  # consisting entirely of digits will be treated as an indexed lookup which means that the value that it is applied to
-  # must be an array. Other types of segments will expect that the given value is something other than a String that
-  # implements the '#[]' method.
-  #
-  # @param key [String] the original key (only used for error messages)
-  # @param lookup_invocation [Invocation] The current lookup invocation
-  # @param segments [Array<String>] the segments to use for lookup
-  # @param value [Object] the value to access using the segments
-  # @return [Object] the value obtained when accessing the value
-  #
-  # @api public
-  def sub_lookup(key, lookup_invocation, segments, value)
-    lookup_invocation.with(:sub_lookup, segments) do
-      segments.each do |segment|
-        lookup_invocation.with(:segment, segment) do
-          if value.nil?
-            lookup_invocation.report_not_found(segment)
-            throw :no_such_key
-          end
-          if 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
-              lookup_invocation.report_not_found(segment)
-              throw :no_such_key
-            end
-          else
-            unless value.respond_to?(:'[]') && !(value.instance_of?(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
-            unless value.include?(segment)
-              lookup_invocation.report_not_found(segment)
-              throw :no_such_key
-            end
-          end
-          value = value[segment]
-          lookup_invocation.report_found(segment, value)
-        end
-      end
-      value
-    end
-  end
-end
-end
-end

data/vendor/gems/puppet-4.5.2/lib/puppet/pops/merge_strategy.rb

@@ -1,338 +0,0 @@
-require 'deep_merge/core'
-
-module Puppet::Pops
-  # Merges to objects into one based on an implemented strategy.
-  #
-  class MergeStrategy
-    NOT_FOUND = Object.new.freeze
-
-    # The type used for validation of the _merge_ argument
-    def self.merge_t
-      @@merge_t ||=  Types::TypeParser.new.parse("Variant[String[1],Runtime[ruby,'Symbol'],Hash[Variant[String[1],Runtime[ruby,'Symbol']],Scalar,1]]")
-    end
-    private_class_method :merge_t
-
-    def self.strategies
-      @@strategies ||= {}
-    end
-    private_class_method :strategies
-
-    # Finds the merge strategy for the given _merge_, creates an instance of it and returns that instance.
-    #
-    # @param merge [MergeStrategy,String,Hash<String,Object>,nil] The merge strategy. Can be a string or symbol denoting the key
-    #   identifier or a hash with options where the key 'strategy' denotes the key
-    # @return [MergeStrategy] The matching merge strategy
-    #
-    def self.strategy(merge)
-      return merge if merge.is_a?(MergeStrategy)
-      merge = :first if merge.nil?
-      Types::TypeAsserter.assert_instance_of("MergeStrategy 'merge' parameter", merge_t, merge)
-      if merge.is_a?(Hash)
-        merge_strategy = merge['strategy']
-        if merge_strategy.nil?
-          raise ArgumentError, "The hash given as 'merge' must contain the name of a strategy in string form for the key 'strategy'"
-        end
-        merge_options  = merge
-      else
-        merge_strategy = merge
-        merge_options  = {}
-      end
-      strategy = strategies[merge_strategy.to_sym]
-      raise ArgumentError, "Unknown merge strategy: '#{merge_strategy}'" if strategy.nil?
-      strategy.new(merge_options)
-    end
-
-    # Returns the list of merge strategy keys known to this class
-    #
-    # @return [Array<Symbol>] List of strategy keys
-    #
-    def self.strategy_keys
-      strategies.keys
-    end
-
-    # Adds a new merge strategy to the map of strategies known to this class
-    #
-    # @param strategy_class [Class<MergeStrategy>] The class of the added strategy
-    #
-    def self.add_strategy(strategy_class)
-      unless MergeStrategy > strategy_class
-        raise ArgumentError, "MergeStrategies.add_strategy 'strategy_class' must be a 'MergeStrategy' class. Got #{strategy_class}"
-      end
-      strategies[strategy_class.key] = strategy_class
-      nil
-    end
-
-    # Finds a merge strategy that corresponds to the given _merge_ argument and delegates the task of merging the elements of _e1_ and _e2_ to it.
-    #
-    # @param e1 [Object] The first element
-    # @param e2 [Object] The second element
-    # @return [Object] The result of the merge
-    #
-    def self.merge(e1, e2, merge)
-      strategy(merge).merge(e1, e2)
-    end
-
-    def self.key
-      raise NotImplementedError, "Subclass must implement 'key'"
-    end
-
-    # Create a new instance of this strategy configured with the given _options_
-    # @param merge_options [Hash<String,Object>] Merge options
-    def initialize(options)
-      assert_type('The merge options', options_t, options)
-      @options = options
-    end
-
-    # Merges the elements of _e1_ and _e2_ according to the rules of this strategy and options given when this
-    # instance was created
-    #
-    # @param e1 [Object] The first element
-    # @param e2 [Object] The second element
-    # @return [Object] The result of the merge
-    #
-    def merge(e1, e2)
-      checked_merge(
-        assert_type('The first element of the merge', value_t, e1),
-        assert_type('The second element of the merge', value_t, e2))
-    end
-
-    # Merges the result of yielding the given _lookup_variants_ to a given block.
-    #
-    # @param lookup_variants [Array] The variants to pass as second argument to the given block
-    # @return [Object] the merged value.
-    # @yield [} ]
-    # @yieldparam variant [Object] each variant given in the _lookup_variants_ array.
-    # @yieldreturn [Object] the value to merge with other values
-    # @throws :no_such_key if the lookup was unsuccessful
-    #
-    def merge_lookup(lookup_variants)
-      result = lookup_variants.reduce(NOT_FOUND) do |memo, lookup_variant|
-        not_found = true
-        value = catch(:no_such_key) do
-          v = yield(lookup_variant)
-          not_found = false
-          v
-        end
-        if not_found
-          memo
-        else
-          memo.equal?(NOT_FOUND) ? convert_value(value) : merge(memo, value)
-        end
-      end
-      throw :no_such_key if result == NOT_FOUND
-      result
-    end
-
-    # Converts a single value to the type expeced when peforming a merge of two elements
-    # @param value [Object] the value to convert
-    # @return [Object] the converted value
-    def convert_value(value)
-      value
-    end
-
-    def options
-      @options
-    end
-
-    def configuration
-      if @options.nil? || @options.empty?
-        self.class.key.to_s
-      else
-        @options.include?('strategy') ? @options : { 'strategy' => self.class.key.to_s }.merge(@options)
-      end
-    end
-
-    protected
-
-    # Returns the type used to validate the options hash
-    #
-    # @return [Types::PStructType] the puppet type
-    #
-    def options_t
-      @options_t ||=Types::TypeParser.new.parse("Struct[{strategy=>Optional[Pattern[#{self.class.key}]]}]")
-    end
-
-    # Returns the type used to validate the options hash
-    #
-    # @return [Types::PAnyType] the puppet type
-    #
-    def value_t
-      raise NotImplementedError, "Subclass must implement 'value_t'"
-    end
-
-    def checked_merge(e1, e2)
-      raise NotImplementedError, "Subclass must implement 'checked_merge(e1,e2)'"
-    end
-
-    def assert_type(param, type, value)
-      Types::TypeAsserter.assert_instance_of(param, type, value)
-    end
-  end
-
-  # Simple strategy that returns the first value found. It never merges any values.
-  #
-  class FirstFoundStrategy < MergeStrategy
-    def self.key
-      :first
-    end
-
-    # Returns the first value found
-    #
-    # @param lookup_variants [Array] The variants to pass as second argument to the given block
-    # @return [Object] the merged value
-    # @throws :no_such_key unless the lookup was successful
-    #
-    def merge_lookup(lookup_variants)
-      lookup_variants.each do |lookup_variant|
-        catch(:no_such_key) { return yield(lookup_variant) }
-      end
-      throw :no_such_key
-    end
-
-    protected
-
-    def value_t
-      @value_t ||= Types::PAnyType::DEFAULT
-    end
-
-    MergeStrategy.add_strategy(self)
-  end
-
-  # Produces a new hash by merging hash e1 with hash e2 in such a way that the values of duplicate keys
-  # will be those of e1
-  #
-  class HashMergeStrategy < MergeStrategy
-    def self.key
-      :hash
-    end
-
-    # @param e1 [Hash<String,Object>] The hash that will act as the source of the merge
-    # @param e2 [Hash<String,Object>] The hash that will act as the receiver for the merge
-    # @return [Hash<String,Object]] The merged hash
-    # @see Hash#merge
-    def checked_merge(e1, e2)
-      e2.merge(e1)
-    end
-
-    protected
-
-    def value_t
-      @value_t ||= Types::TypeParser.new.parse('Hash[String,Data]')
-    end
-
-    MergeStrategy.add_strategy(self)
-  end
-
-  # Merges two values that must be either scalar or arrays into a unique set of values.
-  #
-  # Scalar values will be converted into a one element arrays and array values will be flattened
-  # prior to forming the unique set. The order of the elements is preserved with e1 being the
-  # first contributor of elements and e2 the second.
-  #
-  class UniqueMergeStrategy < MergeStrategy
-    def self.key
-      :unique
-    end
-
-    # @param e1 [Array<Object>] The first array
-    # @param e2 [Array<Object>] The second array
-    # @return [Array<Object>] The unique set of elements
-    #
-    def checked_merge(e1, e2)
-      convert_value(e1) | convert_value(e2)
-    end
-
-    def convert_value(e)
-      e.is_a?(Array) ? e.flatten : [e]
-    end
-
-    protected
-
-    def value_t
-      @value_t ||= Types::TypeParser.new.parse('Variant[Scalar,Array[Data]]')
-    end
-
-    MergeStrategy.add_strategy(self)
-  end
-
-  # Documentation copied from https://github.com/danielsdeleo/deep_merge/blob/master/lib/deep_merge/core.rb
-  # altered with respect to _preserve_unmergeables_ since this implementation always disables that option.
-  #
-  # The destination is dup'ed before the deep_merge is called to allow frozen objects as values.
-  #
-  # deep_merge method permits merging of arbitrary child elements. The two top level
-  # elements must be hashes. These hashes can contain unlimited (to stack limit) levels
-  # of child elements. These child elements to not have to be of the same types.
-  # Where child elements are of the same type, deep_merge will attempt to merge them together.
-  # Where child elements are not of the same type, deep_merge will skip or optionally overwrite
-  # the destination element with the contents of the source element at that level.
-  # So if you have two hashes like this:
-  #   source = {:x => [1,2,3], :y => 2}
-  #   dest =   {:x => [4,5,'6'], :y => [7,8,9]}
-  #   dest.deep_merge!(source)
-  #   Results: {:x => [1,2,3,4,5,'6'], :y => 2}
-  #
-  # "deep_merge" will unconditionally overwrite any unmergeables and merge everything else.
-  #
-  # Options:
-  #   Options are specified in the last parameter passed, which should be in hash format:
-  #   hash.deep_merge!({:x => [1,2]}, {:knockout_prefix => '--'})
-  #   - 'knockout_prefix' Set to string value to signify prefix which deletes elements from existing element. Defaults is _undef_
-  #   - 'sort_merged_arrays' Set to _true_ to sort all arrays that are merged together. Default is _false_
-  #   - 'merge_hash_arrays' Set to _true_ to merge hashes within arrays. Default is _false_
-  #
-  # Selected Options Details:
-  # :knockout_prefix => The purpose of this is to provide a way to remove elements
-  #   from existing Hash by specifying them in a special way in incoming hash
-  #    source = {:x => ['--1', '2']}
-  #    dest   = {:x => ['1', '3']}
-  #    dest.ko_deep_merge!(source)
-  #    Results: {:x => ['2','3']}
-  #   Additionally, if the knockout_prefix is passed alone as a string, it will cause
-  #   the entire element to be removed:
-  #    source = {:x => '--'}
-  #    dest   = {:x => [1,2,3]}
-  #    dest.ko_deep_merge!(source)
-  #    Results: {:x => ""}
-  #
-  # :merge_hash_arrays => merge hashes within arrays
-  #   source = {:x => [{:y => 1}]}
-  #   dest   = {:x => [{:z => 2}]}
-  #   dest.deep_merge!(source, {:merge_hash_arrays => true})
-  #   Results: {:x => [{:y => 1, :z => 2}]}
-  #
-  class DeepMergeStrategy < MergeStrategy
-    def self.key
-      :deep
-    end
-
-    def checked_merge(e1, e2)
-      dm_options = { :preserve_unmergeables => false }
-      options.each_pair { |k,v| dm_options[k.to_sym] = v unless k == 'strategy' }
-      # e2 (the destination) is dup'ed to avoid that the passed in object mutates
-      DeepMerge.deep_merge!(e1, e2.dup, dm_options)
-    end
-
-    protected
-
-    # Returns a type that allows all deep_merge options except 'preserve_unmergeables' since we force
-    # the setting of that option to false
-    #
-    # @return [Types::PAnyType] the puppet type used when validating the options hash
-    def options_t
-      @options_t ||= Types::TypeParser.new.parse('Struct[{'\
-          "strategy=>Optional[Pattern[#{self.class.key}]],"\
-          'knockout_prefix=>Optional[String],'\
-          'merge_debug=>Optional[Boolean],'\
-          'merge_hash_arrays=>Optional[Boolean],'\
-          'sort_merge_arrays=>Optional[Boolean],'\
-          '}]')
-    end
-
-    def value_t
-      @value_t ||= Types::TypeParser.new.parse('Variant[Array[Data],Hash[String,Data]]')
-    end
-
-    MergeStrategy.add_strategy(self)
-  end
-end