(PUP-2950) rubocop - Style/AndOR enabled for the entire puppet #2900

Closed
wants to merge 38 commits into
from
Commits on Jul 29, 2014
  1. @vrthra

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

    vrthra committed Jul 18, 2014
    …ovided 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.
  2. @vrthra

    (PUP-2950) enabling rubocop Style/AndOr cop in pops directory

    vrthra committed Jul 18, 2014
    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.
  3. @vrthra

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

    vrthra committed Jul 18, 2014
    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'
  4. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  5. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  6. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  7. @vrthra

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

    vrthra committed Jul 21, 2014
    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:
  8. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  9. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (autocorrect)

    vrthra committed Jul 21, 2014
    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
  10. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  11. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (enable)

    vrthra committed Jul 25, 2014
    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
  12. @vrthra

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

    vrthra committed Jul 25, 2014
    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
  13. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  14. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  15. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  16. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  17. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  18. @vrthra

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

    vrthra committed Jul 21, 2014
    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'
  19. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  20. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  21. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  22. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  23. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  24. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  25. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  26. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in ext/ (no auto)

    vrthra committed Jul 21, 2014
    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
  27. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  28. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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:
  29. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  30. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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
  31. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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:
  32. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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:
  33. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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:
  34. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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:
  35. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 21, 2014
    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:
  36. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (final fixup)

    vrthra committed Jul 22, 2014
    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:
  37. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 28, 2014
    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
  38. @vrthra

    (PUP-2950) Enable rubocop Style/AndOr in lib/ (no auto)

    vrthra committed Jul 28, 2014
    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