rubocop 0.37.2 → 0.38.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b548479b22a3d4b42dd0cf160e59a5dac37ed348
-  data.tar.gz: 8dffc754b643dd17217ba127b5fcaac29d9eaf7a
+  metadata.gz: c755e82e5751b549039b4eb7556f74a512045e00
+  data.tar.gz: 0c943dff109818624263c8d44e8d533208f066e0
 SHA512:
-  metadata.gz: c6c841494e223ffe783fa455cda9de2fe53068cbf1e1f2477219b83c7f7e404289f211d0481b495991dc94d34c3c9c61cd9cba1e3214f262dc9ba4b57835da98
-  data.tar.gz: 3a06b603d732922bee4ffd5ec8c24d9c3c4b36eb5f26cd9c0bf7cf4d85a281e88afab9dfbed907adf04f56f7cded0b0184b71531e6bfc9980b86534968465efa
+  metadata.gz: 64399fb16df2d1275a11f442b7904d6c036918509eccaffc2be52feea9ed1509d7f5d83c4f9b0eba7542c6d41c60d55c0a5d6ccf7a4c035569b510fcfc014345
+  data.tar.gz: d87cb665637072f82c9b95800d784e0457c817d7da5a4c95ac55675b1ac71447bd54074fc4018488b949d1e10394379961485583c0314d5385d6d57f6b40ae86

data/README.md

@@ -115,7 +115,7 @@ haven't reached version 1.0 yet). To prevent an unwanted RuboCop update you
 might want to use a conservative version locking in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 0.37.2', require: false
+gem 'rubocop', '~> 0.38.0', require: false
 ```
 
 ## Basic Usage
@@ -198,6 +198,7 @@ Command flag              | Description
 `--show-cops`             | Shows available cops and their configuration.
 `--fail-level`            | Minimum [severity](#severity) for exit with error code. Full severity name or upper case initial can be given. Normally, auto-corrected offenses are ignored. Use `A` or `autocorrect` if you'd like them to trigger failure.
 `-s/--stdin`              | Pipe source from STDIN. This is useful for editor integration.
+`--[no-]color`            | Force color output on or off.
 
 ### Cops
 

data/assets/output.html.erb

@@ -161,6 +161,9 @@
     color: #777;
     text-align: right;
     }
+    .extra-code {
+      color: #ED9C28
+    }
     </style>
 
     <script>

data/config/default.yml

@@ -892,7 +892,7 @@ Style/TrivialAccessors:
   #
   # This way you can uncover "hidden" attributes in your code.
   ExactNameMatch: true
-  AllowPredicates: false
+  AllowPredicates: true
   # Allows trivial writers that don't end in an equal sign. e.g.
   #
   # def on_exception(action)
@@ -989,6 +989,19 @@ Metrics/PerceivedComplexity:
 Lint/AssignmentInCondition:
   AllowSafeAssignment: true
 
+# checks whether the end keywords are aligned properly for `do` `end` blocks.
+Lint/BlockAlignment:
+  # The value `start_of_block` means that the `end` should be aligned with line
+  # where the `do` keyword appears.
+  # The value `start_of_line` means it should be aligned with the whole 
+  # expression's starting line.
+  # The value `either` means both are allowed.
+  AlignWith: either
+  SupportedStyles:
+    - either
+    - start_of_block
+    - start_of_line
+
 # Align ends correctly.
 Lint/EndAlignment:
   # The value `keyword` means that `end` should be aligned with the matching

data/config/disabled.yml

@@ -123,7 +123,3 @@ Style/SymbolArray:
   Description: 'Use %i or %I for arrays of symbols.'
   StyleGuide: 'https://github.com/bbatsov/ruby-style-guide#percent-i'
   Enabled: false
-
-Lint/LiteralInInterpolation:
-  Description: 'Avoid interpolating literals in strings'
-  AutoCorrect: false

data/lib/rubocop.rb

@@ -49,7 +49,6 @@ require 'rubocop/cop/mixin/annotation_comment'
 require 'rubocop/cop/mixin/array_hash_indentation'
 require 'rubocop/cop/mixin/array_syntax'
 require 'rubocop/cop/mixin/autocorrect_alignment'
-require 'rubocop/cop/mixin/autocorrect_unless_changing_ast'
 require 'rubocop/cop/mixin/check_assignment'
 require 'rubocop/cop/mixin/configurable_max'
 require 'rubocop/cop/mixin/code_length' # relies on configurable_max

data/lib/rubocop/ast_node.rb

@@ -462,6 +462,12 @@ module RuboCop
         source_range.begin_pos == loc.selector.begin_pos
     end
 
+    def binary_operation?
+      return false unless loc.respond_to?(:selector) && loc.selector
+      Cop::Util.operator?(method_name) &&
+        source_range.begin_pos != loc.selector.begin_pos
+    end
+
     def chained?
       return false if parent.nil? || !parent.send_type?
       receiver, _method_name, *_args = *parent

data/lib/rubocop/ast_node/traversal.rb

@@ -143,7 +143,6 @@ module RuboCop
       end
 
       alias on_until  on_while
-      alias on_when   on_while
       alias on_module on_while
       alias on_sclass on_while
 
@@ -167,6 +166,7 @@ module RuboCop
       alias on_resbody on_case
       alias on_ensure  on_case
       alias on_for     on_case
+      alias on_when    on_case
     end
   end
 end

data/lib/rubocop/cached_data.rb

@@ -53,8 +53,12 @@ module RuboCop
         location = Parser::Source::Range.new(source_buffer,
                                              o['location']['begin_pos'],
                                              o['location']['end_pos'])
-        Cop::Offense.new(o['severity'], location, o['message'], o['cop_name'],
-                         o['status'].to_sym)
+        Cop::Offense.new(o['severity'], location,
+                         # We know that we wrote a UTF-8 encoded string to the
+                         # cache file, so it's safe to force-encode it back to
+                         # UTF-8 if it happens to be ASCII-8BIT.
+                         o['message'].force_encoding('UTF-8'),
+                         o['cop_name'], o['status'].to_sym)
       end
     end
   end

data/lib/rubocop/config_loader.rb

@@ -35,7 +35,10 @@ module RuboCop
         resolve_inheritance_from_gems(hash, hash.delete('inherit_gem'))
         resolve_inheritance(path, hash)
 
-        Array(hash.delete('require')).each { |r| require(r) }
+        config_dir = File.dirname(path)
+        Array(hash.delete('require')).each do |r|
+          require(File.join(config_dir, r))
+        end
 
         hash.delete('inherit_from')
         config = Config.new(hash, path)
@@ -66,7 +69,7 @@ module RuboCop
       def base_configs(path, inherit_from)
         configs = Array(inherit_from).compact.map do |f|
           if f =~ /\A#{URI.regexp(%w(http https))}\z/
-            f = RemoteConfig.new(f).file
+            f = RemoteConfig.new(f, File.dirname(path)).file
           else
             f = File.expand_path(f, File.dirname(path))
 
@@ -210,7 +213,8 @@ module RuboCop
           break if dir_pathname.to_s == @root_level
           dirs_to_search << dir_pathname.to_s
         end
-        dirs_to_search << Dir.home
+        dirs_to_search << Dir.home if ENV.key? 'HOME'
+        dirs_to_search
       end
 
       def old_auto_config_file_warning

data/lib/rubocop/cop/cop.rb

@@ -157,7 +157,7 @@ module RuboCop
       end
 
       def add_offense(node, loc, message = nil, severity = nil)
-        location = loc.is_a?(Symbol) ? node.loc.send(loc) : loc
+        location = loc.is_a?(Symbol) ? node.loc.public_send(loc) : loc
 
         # Don't include the same location twice for one cop.
         return if @offenses.any? { |o| o.location == location }

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -7,13 +7,40 @@ module RuboCop
       # This cop checks whether the end keywords are aligned properly for do
       # end blocks.
       #
+      # Three modes are supported through the `AlignWith` configuration
+      # parameter:
+      #
+      # `start_of_block` : the `end` shall be aligned with the
+      # start of the line where the `do` appeared.
+      #
+      # `start_of_line` : the `end` shall be aligned with the
+      # start of the line where the expression started.
+      #
+      # `either` (which is the default) : the `end` is allowed to be in either
+      # location. The autofixer will default to `start_of_line`.
+      #
       # @example
       #
+      #   # either
       #   variable = lambda do |i|
       #     i
       #   end
+      #
+      #   # start_of_block
+      #   foo.bar
+      #     .each do
+      #        baz
+      #      end
+      #
+      #   # start_of_line
+      #   foo.bar
+      #     .each do
+      #        baz
+      #   end
       class BlockAlignment < Cop
-        MSG = '`%s` at %d, %d is not aligned with `%s` at %d, %d%s.'.freeze
+        include ConfigurableEnforcedStyle
+
+        MSG = '%s is not aligned with %s%s.'.freeze
 
         def_node_matcher :block_end_align_target?, <<-PATTERN
           {assignment?
@@ -28,6 +55,10 @@ module RuboCop
           check_block_alignment(start_for_block_node(node), node)
         end
 
+        def parameter_name
+          'AlignWith'
+        end
+
         private
 
         def start_for_block_node(block_node)
@@ -53,9 +84,30 @@ module RuboCop
           return unless begins_its_line?(end_loc)
 
           start_loc = start_node.source_range
-          return unless start_loc.column != end_loc.column
+          return unless start_loc.column != end_loc.column ||
+                        style == :start_of_block
+
+          do_source_line_column =
+            compute_do_source_line_column(block_node, end_loc)
+          return unless do_source_line_column
+
+          error_source_line_column = if style == :start_of_block
+                                       do_source_line_column
+                                     else
+                                       loc_to_source_line_column(start_loc)
+                                     end
+
+          fmt = format(
+            MSG,
+            format_source_line_column(loc_to_source_line_column(end_loc)),
+            format_source_line_column(error_source_line_column),
+            alt_start_msg(start_loc, do_source_line_column)
+          )
+          add_offense(block_node, end_loc, fmt)
+        end
 
-          do_loc = block_node.loc.begin # Actually it's either do or {.
+        def compute_do_source_line_column(node, end_loc)
+          do_loc = node.loc.begin # Actually it's either do or {.
 
           # We've found that "end" is not aligned with the start node (which
           # can be a block, a variable assignment, etc). But we also allow
@@ -64,24 +116,46 @@ module RuboCop
           # blocks.
           match = /\S.*/.match(do_loc.source_line)
           indentation_of_do_line = match.begin(0)
-          return unless end_loc.column != indentation_of_do_line
-
-          add_offense(block_node,
-                      end_loc,
-                      format(MSG, end_loc.source, end_loc.line, end_loc.column,
-                             start_loc.source.lines.to_a.first.chomp,
-                             start_loc.line, start_loc.column,
-                             alt_start_msg(match, start_loc, do_loc,
-                                           indentation_of_do_line)))
+          return unless end_loc.column != indentation_of_do_line ||
+                        style == :start_of_line
+
+          {
+            source: match[0],
+            line: do_loc.line,
+            column: indentation_of_do_line
+          }
+        end
+
+        def loc_to_source_line_column(loc)
+          {
+            source: loc.source.lines.to_a.first.chomp,
+            line: loc.line,
+            column: loc.column
+          }
         end
 
-        def alt_start_msg(match, start_loc, do_loc, indentation_of_do_line)
-          if start_loc.line == do_loc.line &&
-             start_loc.column == indentation_of_do_line
+        def alt_start_msg(start_loc, source_line_column)
+          if style != :either
+            ''
+          elsif start_loc.line == source_line_column[:line] &&
+                start_loc.column == source_line_column[:column]
             ''
           else
-            " or `#{match[0]}` at #{do_loc.line}, #{indentation_of_do_line}"
+            ' or ' + format_source_line_column(source_line_column)
+          end
+        end
+
+        def format_source_line_column(source_line_column)
+          "`#{source_line_column[:source]}` at #{source_line_column[:line]}, " \
+          "#{source_line_column[:column]}"
+        end
+
+        def compute_start_col(ancestor_node, node)
+          if style == :start_of_block
+            do_loc = node.loc.begin
+            return do_loc.source_line =~ /\S/
           end
+          (ancestor_node || node).source_range.column
         end
 
         def autocorrect(node)
@@ -89,9 +163,9 @@ module RuboCop
           source = node.source_range.source_buffer
 
           lambda do |corrector|
-            start_col = (ancestor_node || node).source_range.column
             starting_position_of_block_end = node.loc.end.begin_pos
             end_col = node.loc.end.column
+            start_col = compute_start_col(ancestor_node, node)
 
             if end_col < start_col
               delta = start_col - end_col

data/lib/rubocop/cop/lint/else_layout.rb

@@ -29,24 +29,34 @@ module RuboCop
 
         def check(node)
           return unless node
+          return check_else(node) if else?(node)
 
-          if node.loc.respond_to?(:else) &&
-             node.loc.else &&
-             node.loc.else.is?('else')
-            _cond, _if_branch, else_branch = *node
+          check_if(node) if if?(node)
+        end
+
+        def check_else(node)
+          _cond, _if_branch, else_branch = *node
+          return unless else_branch && else_branch.type == :begin
 
-            return unless else_branch && else_branch.type == :begin
+          first_else_expr = else_branch.children.first
+          return unless first_else_expr.source_range.line == node.loc.else.line
+
+          add_offense(first_else_expr, :expression, message)
+        end
 
-            first_else_expr = else_branch.children.first
+        def check_if(node)
+          _cond, _if_branch, else_branch = *node
+          check(else_branch)
+        end
+
+        def if?(node)
+          node.loc.respond_to?(:keyword) &&
+            %w(if elsif).include?(node.loc.keyword.source)
+        end
 
-            if first_else_expr.source_range.line == node.loc.else.line
-              add_offense(first_else_expr, :expression, message)
-            end
-          elsif node.loc.respond_to?(:keyword) &&
-                %w(if elsif).include?(node.loc.keyword.source)
-            _cond, _if_branch, else_branch = *node
-            check(else_branch)
-          end
+        def else?(node)
+          node.loc.respond_to?(:else) && node.loc.else &&
+            node.loc.else.is?('else')
         end
 
         def message

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -34,20 +34,14 @@ module RuboCop
 
         def offending_node?(node)
           return false unless called_on_string?(node)
+          return false unless sprintf?(node) || format?(node) || percent?(node)
+          return false if named_mode?(node) || node_with_splat_args?(node)
 
-          if sprintf?(node) || format?(node) || percent?(node)
-            if named_mode?(node) || node_with_splat_args?(node)
-              false
-            else
-              num_of_format_args, num_of_expected_fields = count_matches(node)
+          num_of_format_args, num_of_expected_fields = count_matches(node)
 
-              num_of_format_args != :unknown &&
-                num_of_expected_fields != :unknown &&
-                num_of_expected_fields != num_of_format_args
-            end
-          else
-            false
-          end
+          num_of_format_args != :unknown &&
+            num_of_expected_fields != :unknown &&
+            num_of_expected_fields != num_of_format_args
         end
 
         def called_on_string?(node)

data/lib/rubocop/cop/lint/implicit_string_concatenation.rb

@@ -27,16 +27,7 @@ module RuboCop
                      'arguments, separate them with a comma.'.freeze
 
         def on_dstr(node)
-          node.children.each_cons(2) do |child1, child2|
-            # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
-            next unless string_literal?(child1) && string_literal?(child2)
-            next unless child1.loc.last_line == child2.loc.line
-
-            # Make sure we don't flag a string literal which simply has
-            # embedded newlines
-            # `"abc\ndef"` also -> (dstr (str "abc") (str "def"))
-            next unless child1.source[-1] == ending_delimiter(child1)
-
+          each_bad_cons(node) do |child1, child2|
             range   = child1.source_range.join(child2.source_range)
             message = format(MSG, display_str(child1), display_str(child2))
             if node.parent && node.parent.array_type?
@@ -50,6 +41,21 @@ module RuboCop
 
         private
 
+        def each_bad_cons(node)
+          node.children.each_cons(2) do |child1, child2|
+            # `'abc' 'def'` -> (dstr (str "abc") (str "def"))
+            next unless string_literal?(child1) && string_literal?(child2)
+            next unless child1.loc.last_line == child2.loc.line
+
+            # Make sure we don't flag a string literal which simply has
+            # embedded newlines
+            # `"abc\ndef"` also -> (dstr (str "abc") (str "def"))
+            next unless child1.source[-1] == ending_delimiter(child1)
+
+            yield child1, child2
+          end
+        end
+
         def ending_delimiter(str)
           # implicit string concatenation does not work with %{}, etc.
           if str.source[0] == "'"

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -27,7 +27,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_or_module_new_call?, <<-PATTERN
-          (block (send (const nil {:Class :Module}) :new) ...)
+          (block (send (const nil {:Class :Module}) :new ...) ...)
         PATTERN
 
         def on_method_def(node, _method_name, _args, _body)