(PUP-2950) ensure that default layer is used when the user has not provided a layer

Without this patch,

```
      unless diagnostics.errors?
        @layering_config   = data['layers'] or default_layers
        @scheme_extensions = (data['extensions'] and
                  data['extensions']['scheme_handlers'] or
                  default_scheme_extensions)
      else
        @layering_config = []
        @scheme_extensions = {}
      end
```
This would have resulted in @layering_config not being assigned a value if no
layers was set. This is clearly not intented. This patch updates the behavior
so that `@layering_config` is assigned default_layers instead
(by changing `or` to `||`)

This commit also adds test cases to verify that this case is caught.
(PUP-2950) enabling rubocop Style/AndOr cop in pops directory

This commits enables `AndOr` cop only in lib/puppet/pops directory. This cop
bans the use of `and` and `or` keywords in favor of `&&` and `||`. We have
chosen this directory as a test case to evaluate the utility of enabling
`AndOr` on the complete codebase. We inherit from the base rubocop file, so all
the other cops remain enabled. At a future date, when `AndOr` is enabled
systemwide, this file may be removed (if no other specialization exists on pops
directory).

It changes all code that uses `and` and `or` keywords to use `&&` and
`||`  instead. Note that this commit only fixes the lib/puppet/pops directory.
Further, for ease of verification of correctness, redundant parenthesis has
been used around the expressions thus converted where there was felt to be
a possibility of confusion.
(PUP-2950) Enable rubocop Style/AndOr in lib/ (enable)

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

This commit enables the `AndOr` cop
(PUP-2950) Enable rubocop Style/AndOr in lib/ (autocorrect)

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

Rubocop: autocorrect
(PUP-2950) Enable rubocop Style/AndOr in lib/ (fix spacing)

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:
    Replacing only the simplest pattern

    s#^( *)if +([^ ]+) +and +([^ ]+)$#$1if $2 && $3#g
    s#^( *)if +([^ ]+) +or +([^ ]+)$#$1if $2 || $3#g
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

Replacing only the simplest patterns

's#^(.*) if +([^ ]+) +or +([^ ]+)$#$1 if $2 || $3#g'
's#^(.*) if +([^ ]+) +and +([^ ]+)$#$1 if $2 && $3#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

Replacing only the pattern
's#^(.*) if +([^ ]+) +([!=~+-<>]+) +([^ ]+) and ([^ ]+) ([!=~+-><]+) +([^ \n]+)$#$1 if ($2 $3 $4) && ($5 $6 $7)#g'
's#^(.*) if +([^ ]+) +([!=~+-<>]+) +([^ ]+) or ([^ ]+) ([!=~+-><]+) +([^ \n]+)$#$1 if ($2 $3 $4) || ($5 $6 $7)#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

's#^(.*) if +([^ ]+) +([!=~+-<>]+) +([^ ]+) or ([^ \n]+)$#$1 if ($2 $3 $4) || $5#g'
's#^(.*) if +([^ ]+) or ([^ ]+) ([!=~+-><]+) +([^ \n]+)$#$1 if $2 || ($3 $4 $5)#g'
's#^(.*) if +([^ ]+) +([!=~+-<>]+) +([^ ]+) and ([^ \n]+)$#$1 if ($2 $3 $4) && $5#g'
's#^(.*) if +([^ ]+) and ([^ ]+) ([!=~+-><]+) +([^ \n]+)$#$1 if $2 && ($3 $4 $5)#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

Only patterns
's#(.*) +unless +([^ ]+) +or +([^ ]+)$#$1 unless $2 || $3#g'
's#(.*) +unless +([^ ]+) +and +([^ ]+)$#$1 unless $2 && $3#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

'%s#if ([^ ]+) and ([^ ]+) then#if $1 && $2 then#g'
'%s#if ([^ ]+) or ([^ ]+) then#if $1 || $2 then#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

replacing only patterns

's#([ ]*)if +([^ ]+) +and +([^ ]+)$#${1}if $2 && $3#g'
's#([ ]*)if +([^ ]+) +or +([^ ]+)$#${1}if $2 || $3#g'
's#([ ]*)if +([^ ]+) +and not +([^ ]+)$#${1}if $2 && !$3#g'
's#([ ]*)if not +([^ ]+) +and not +([^ ]+)$#${1}if !$2 && !$3#g'
's#([ ]*)if not +([^ ]+) +and +([^ ]+)$#${1}if !$2 && $3#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

Replacing only patterns

's#^([^ ]+) +and +([^ ]+)$#$1 && $2#g'
's#^([^ ]+) +or +([^ ]+)$#$1 || $2#g'
's#^( *[^ ]+) +and +([^ ]+)$#$1 && $2#g'
's#^( *[^ ]+) +or +([^ ]+)$#$1 || $2#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

'%s#if ([^ ]+) and ([^ ]+)#if $1 and $2#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

'%s#(.*) if ([^ ]+) and ([^ ]+) #$1 if $2 and $3 #g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

'%s#(.*) if ([^ ]+) ([=!~]+) and ([^ ]+) #$1 if ($2) && $3 #g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

's#^( *)([^ ]+) +or raise (.*)$#$1$2 || (raise $3)#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:

's#^( *)([^ ]+) +or return (.*)$#$1$2 || (return $3)#g'
(PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:
  by hand
(PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

This is part of a series of commits that follows the same pattern. These
checkins remove use of `and` and `or` keywords, and enable the Style/AndOr cop
so that future use of `and` and `or` is banned (and instead `&&` and `||` is
encouraged)

For the ease of modification, and to ensure that the possible errors remain a
minimum, we have attempted to make the changes as consistent to each other as
possible, and have also given preference to explicit parenthesis where doing so
helped.

Our approach has been to
- Let rubocopop autocorrect where possible
- Look for regular expression patterns that could catch the maximum number of
  violations without ambiguity, and apply these to the code, and then manually
  verify that the changes have indeed been correct (and correct where
  necessary).
- Once such patterns were exhausted, the remaining changes were done by hand.

REGEX USED:
  by hand