rubocop 0.41.1 → 0.41.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86879d377fb20fd602a7bd74846127dabff3eaff
-  data.tar.gz: 667de06f4b8796dcdc48bd8c84da7687df8c7503
+  metadata.gz: 1a7d6fcd2f40430ad14bde72540681109b1e9f5b
+  data.tar.gz: af9a00491131661fdd1866f9b6b774c7ed92763c
 SHA512:
-  metadata.gz: 9286cdc9b1842a27df0a884ab5c7e33b6e7162fa29507d810ba7c27b1f4fadc960c3502a64b0855726e0ab664fb5d36a4c685eac11c9286bd597e9aac9aaebca
-  data.tar.gz: cb042872468b5309744a002bc052d2601c344efd1773265d0b463a00c7b5e3931aa4ac85daf974104b81ac8e9877bf436cf08fd554bae331f25b82b308241a96
+  metadata.gz: 3eb3c0f92e9455c4225a7eb7c571227db0b6cb3563ab746029c3d108d0146ce68762e5a4f8193acc8e0f92172ade66f102a3bcb24488c06cc749ef82826e7e26
+  data.tar.gz: 152966c8fc530fad493837af8e58a5d8128d17b0fbe2514f9b8f14db104b68ef31e3275f8036abd5b41dec4fbdb5184eee44b79e836c305f80ae90df7e9a329d

data/README.md

@@ -51,7 +51,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.41.1', require: false
+gem 'rubocop', '~> 0.41.2', require: false
 ```
 
 ## Quickstart

data/config/default.yml

@@ -73,9 +73,12 @@ AllCops:
   # cache location is secure from this kind of attack, and wish to use a
   # symlinked cache location, set this value to "true".
   AllowSymlinksInCacheRootDirectory: false
-  # What version of the Ruby interpreter is the inspected code intended to
+  # What MRI version of the Ruby interpreter is the inspected code intended to
   # run on? (If there is more than one, set this to the lowest version.)
-  TargetRubyVersion: 2.0
+  # If a value is specified for TargetRubyVersion then it is used.
+  # Else if .ruby-version exists and it contains an MRI version it is used.
+  # Otherwise we fallback to the oldest officially supported Ruby version (2.0).
+  TargetRubyVersion: ~
 
 # Indent private/protected/public as deep as method definitions
 Style/AccessModifierIndentation:

data/lib/rubocop/comment_config.rb

@@ -7,7 +7,7 @@ module RuboCop
   class CommentConfig
     UNNEEDED_DISABLE = 'Lint/UnneededDisable'.freeze
 
-    COP_NAME_PATTERN = '([A-Z][a-z]+/)?(?:[A-Z][a-z]+)+'.freeze
+    COP_NAME_PATTERN = '([A-Z]\w+/)?(?:[A-Z]\w+)'.freeze
     COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}".freeze
     COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})".freeze
 

data/lib/rubocop/config.rb

@@ -16,6 +16,8 @@ module RuboCop
 
     COMMON_PARAMS = %w(Exclude Include Severity
                        AutoCorrect StyleGuide Details).freeze
+    # 2.0 is the oldest officially supported Ruby version.
+    DEFAULT_RUBY_VERSION = 2.0
     KNOWN_RUBIES = [1.9, 2.0, 2.1, 2.2, 2.3].freeze
     OBSOLETE_COPS = {
       'Style/TrailingComma' =>
@@ -196,14 +198,18 @@ module RuboCop
 
     def target_ruby_version
       @target_ruby_version ||=
-        if File.file?('.ruby-version')
-          @target_ruby_version_source = :dot_ruby_version
-
-          File.read('.ruby-version').to_f
-        else
+        if for_all_cops['TargetRubyVersion']
           @target_ruby_version_source = :rubocop_yml
 
           for_all_cops['TargetRubyVersion']
+        elsif File.file?('.ruby-version') &&
+              /\A(ruby-)?(?<version>\d+\.\d+)/ =~ File.read('.ruby-version')
+
+          @target_ruby_version_source = :dot_ruby_version
+
+          version.to_f
+        else
+          DEFAULT_RUBY_VERSION
         end
     end
 

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

@@ -39,17 +39,26 @@ module RuboCop
           end
 
           rescue_group_rescues_multiple_levels = rescued_groups.any? do |group|
-            !contains_multiple_levels_of_exceptions?(group)
+            contains_multiple_levels_of_exceptions?(group)
           end
 
-          return if rescue_group_rescues_multiple_levels &&
+          return if !rescue_group_rescues_multiple_levels &&
                     rescued_groups == sort_rescued_groups(rescued_groups)
 
-          add_offense(node, :expression)
+          add_offense(node, offense_range(node, rescues))
         end
 
         private
 
+        def offense_range(node, rescues)
+          first_rescue = rescues.first
+          last_rescue = rescues.last
+          last_exceptions, = *last_rescue
+          Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                    first_rescue.loc.expression.begin_pos,
+                                    last_exceptions.loc.expression.end_pos)
+        end
+
         def rescue_modifier?(node)
           node && node.rescue_type? &&
             (node.parent.nil? || !(node.parent.kwbegin_type? ||
@@ -69,8 +78,7 @@ module RuboCop
 
         def evaluate_exceptions(rescue_group)
           if rescue_group
-            rescued_exceptions = rescue_group.source.delete(' ').split(',')
-
+            rescued_exceptions = rescued_exceptions(rescue_group)
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
                 converted << instance_eval(exception, __FILE__, __LINE__)
@@ -89,6 +97,21 @@ module RuboCop
             x <=> y || 0
           end
         end
+
+        # @param [RuboCop::Node] rescue_group is a node of array_type
+        def rescued_exceptions(rescue_group)
+          klasses = *rescue_group
+          klasses.map do |klass|
+            # `rescue nil` is valid syntax in all versions of Ruby. In Ruby
+            # 1.9.3, it effectively disables the `rescue`. In versions
+            # after 1.9.3, a `TypeError` is thrown when the statement is
+            # rescued. In order to account for this, we convert `nil` to
+            # `NilClass`.
+            next 'NilClass' if klass.nil_type?
+            next unless klass.const_type?
+            klass.source
+          end.compact
+        end
       end
     end
   end

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

@@ -31,27 +31,34 @@ module RuboCop
 
         def autocorrect(args)
           lambda do |corrector|
-            ranges, range = *args # ranges are sorted by position
+            ranges, range = *args # Ranges are sorted by position.
 
             if range.source.start_with?('#')
-              # eat the entire comment and following newline
-              corrector.remove(range_with_surrounding_space(range, :right))
+              # Eat the entire comment, the preceding space, and the preceding
+              # newline if there is one.
+              original_begin = range.begin_pos
+              range = range_with_surrounding_space(range, :left, true)
+              range = range_with_surrounding_space(range, :right,
+                                                   # Special for a comment that
+                                                   # begins the file: remove
+                                                   # the newline at the end.
+                                                   original_begin == 0)
             else
-              # is there any cop between this one and the end of the line, which
+              # Is there any cop between this one and the end of the line, which
               # is NOT being removed?
 
               if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
-                # eat the comma on the left
+                # Eat the comma on the left.
                 range = range_with_surrounding_space(range, :left)
                 range = range_with_surrounding_comma(range, :left)
               end
 
               range = range_with_surrounding_comma(range, :right)
-              # eat following spaces up to EOL, but not the newline itself
+              # Eat following spaces up to EOL, but not the newline itself.
               range = range_with_surrounding_space(range, :right, false)
-
-              corrector.remove(range)
             end
+
+            corrector.remove(range)
           end
         end
 

data/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -36,8 +36,9 @@ module RuboCop
         line_nos.each do |lineno|
           next if comment_lines.include?(lineno + 1)
           line = processed_source.lines[lineno]
-          next if line =~ /\A\s*\Z/
-          next if indent && indent != (line =~ /\S/)
+          index = line =~ /\S/
+          next unless index
+          next if indent && indent != index
           return yield(range, line)
         end
         false

data/lib/rubocop/cop/performance/redundant_block_call.rb

@@ -85,7 +85,7 @@ module RuboCop
             new_source << args.map(&:source).join(', ')
           end
 
-          new_source << CLOSE_PAREN if parentheses?(node)
+          new_source << CLOSE_PAREN if parentheses?(node) && !args.empty?
           ->(corrector) { corrector.replace(node.source_range, new_source) }
         end
       end

data/lib/rubocop/cop/performance/string_replacement.rb

@@ -49,18 +49,22 @@ module RuboCop
             first_source = interpret_string_escapes(first_source)
           end
 
-          replacement_method = replacement_method(method,
-                                                  first_source,
-                                                  second_source)
+          replacement_method =
+            replacement_method(method, first_source, second_source)
+
+          replace_method(node, first_source, second_source, first_param,
+                         replacement_method)
+        end
 
+        def replace_method(node, first, second, first_param, replacement)
           lambda do |corrector|
-            corrector.replace(node.loc.selector, replacement_method)
+            corrector.replace(node.loc.selector, replacement)
             unless first_param.str_type?
               corrector.replace(first_param.source_range,
-                                to_string_literal(first_source))
+                                to_string_literal(first))
             end
 
-            if second_source.empty? && first_source.length == 1
+            if second.empty? && first.length == 1
               remove_second_param(corrector, node, first_param)
             end
           end

data/lib/rubocop/cop/rails/output_safety.rb

@@ -27,8 +27,8 @@ module RuboCop
       #   safe_join(out)
       #
       class OutputSafety < Cop
-        MSG = 'Tagging a string as html safe may be a security risk, \
-          prefer `safe_join` or other Rails tag helpers instead'.freeze
+        MSG = 'Tagging a string as html safe may be a security risk, ' \
+              'prefer `safe_join` or other Rails tag helpers instead'.freeze
 
         def on_send(node)
           receiver, method_name, *_args = *node

data/lib/rubocop/cop/rails/time_zone.rb

@@ -151,7 +151,11 @@ module RuboCop
         end
 
         def good_methods
-          style == :strict ? [:zone] : [:zone, :current] + ACCEPTED_METHODS
+          if style == :strict
+            [:zone, :zone_default]
+          else
+            [:zone, :zone_default, :current] + ACCEPTED_METHODS
+          end
         end
 
         def acceptable_methods(klass, method_name, node)

data/lib/rubocop/cop/style/ascii_comments.rb

@@ -11,9 +11,29 @@ module RuboCop
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            add_offense(comment, :expression) unless comment.text.ascii_only?
+            unless comment.text.ascii_only?
+              add_offense(comment, first_offense_range(comment))
+            end
           end
         end
+
+        private
+
+        def first_offense_range(comment)
+          expression    = comment.loc.expression
+          first_offense = first_non_ascii_chars(comment.text)
+
+          start_position = expression.begin_pos +
+                           comment.text.index(first_offense)
+          end_position   = start_position + first_offense.length
+
+          Parser::Source::Range.new(comment.loc.expression.source_buffer,
+                                    start_position, end_position)
+        end
+
+        def first_non_ascii_chars(string)
+          string.match(/[^[:ascii:]]+/).to_s
+        end
       end
     end
   end

data/lib/rubocop/cop/style/ascii_identifiers.rb

@@ -9,11 +9,29 @@ module RuboCop
         MSG = 'Use only ascii symbols in identifiers.'.freeze
 
         def investigate(processed_source)
-          processed_source.tokens.each do |t|
-            next unless t.type == :tIDENTIFIER && !t.text.ascii_only?
-            add_offense(nil, t.pos)
+          processed_source.tokens.each do |token|
+            next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
+            add_offense(token, first_offense_range(token))
           end
         end
+
+        private
+
+        def first_offense_range(identifier)
+          expression    = identifier.pos
+          first_offense = first_non_ascii_chars(identifier.text)
+
+          start_position = expression.begin_pos +
+                           identifier.text.index(first_offense)
+          end_position   = start_position + first_offense.length
+
+          Parser::Source::Range.new(identifier.pos.source_buffer,
+                                    start_position, end_position)
+        end
+
+        def first_non_ascii_chars(string)
+          string.match(/[^[:ascii:]]+/).to_s
+        end
       end
     end
   end

data/lib/rubocop/cop/style/block_delimiters.rb

@@ -6,7 +6,7 @@ module RuboCop
     module Style
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
-      class BlockDelimiters < Cop
+      class BlockDelimiters < Cop # rubocop:disable Metrics/ClassLength
         include ConfigurableEnforcedStyle
 
         def on_send(node)
@@ -79,9 +79,11 @@ module RuboCop
             if b.is?('{')
               corrector.insert_before(b, ' ') unless whitespace_before?(b)
               corrector.insert_before(e, ' ') unless whitespace_before?(e)
+              corrector.insert_after(b, ' ') unless whitespace_after?(b)
               corrector.replace(b, 'do')
               corrector.replace(e, 'end')
             else
+              corrector.insert_after(b, ' ') unless whitespace_after?(b, 2)
               corrector.replace(b, '{')
               corrector.replace(e, '}')
             end
@@ -92,6 +94,10 @@ module RuboCop
           node.source_buffer.source[node.begin_pos - 1, 1] =~ /\s/
         end
 
+        def whitespace_after?(node, length = 1)
+          node.source_buffer.source[node.begin_pos + length, 1] =~ /\s/
+        end
+
         def get_blocks(node, &block)
           case node.type
           when :block

data/lib/rubocop/cop/style/method_call_parentheses.rb

@@ -37,10 +37,6 @@ module RuboCop
           _receiver, method_name, *_args = *node
 
           node.each_ancestor(*ASGN_NODES).any? do |asgn_node|
-            if asgn_node.masgn_type?
-              mlhs_node, _mrhs_node = *asgn_node
-              asgn_node = mlhs_node.children[node.sibling_index]
-            end
             # `obj.method = value` parses as (send ... :method= ...), and will
             # not be returned as an `asgn_node` here
             # however, `obj.method ||= value` parses as (or-asgn (send ...) ...)
@@ -50,6 +46,14 @@ module RuboCop
               return false if asgn_node.send_type?
             end
 
+            if asgn_node.masgn_type?
+              mlhs_node, _mrhs_node = *asgn_node
+              var_nodes = *mlhs_node
+              vars = var_nodes.map { |n| (_b = *n).first }
+
+              return vars.include?(method_name)
+            end
+
             asgn_node.loc.name.source == method_name.to_s
           end
         end

data/lib/rubocop/cop/style/raise_args.rb

@@ -75,7 +75,12 @@ module RuboCop
         def correction_compact_to_exploded(node)
           exception_node, _new, message_node = *node.first
 
-          "#{exception_node.const_name}, #{message_node.source}"
+          message = message_node && message_node.source
+
+          correction = exception_node.const_name.to_s
+          correction = "#{correction}, #{message}" if message
+
+          correction
         end
 
         def correction_exploded_to_compact(node)

data/lib/rubocop/cop/style/special_global_vars.rb

@@ -76,23 +76,7 @@ module RuboCop
           global_var, = *node
 
           if style == :use_english_names
-            regular, english = ENGLISH_VARS[global_var].partition do |var|
-              NON_ENGLISH_VARS.include? var
-            end
-
-            # For now, we assume that lists are 2 items or less. Easy grammar!
-            regular_msg = regular.join('` or `')
-            english_msg = english.join('` or `')
-
-            if !regular.empty? && !english.empty?
-              format(MSG_BOTH, english_msg, regular_msg, global_var)
-            elsif !regular.empty?
-              format(MSG_REGULAR, regular_msg, global_var)
-            elsif !english.empty?
-              format(MSG_ENGLISH, english_msg, global_var)
-            else
-              raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
-            end
+            format_english_message(global_var)
           else
             format(MSG_REGULAR, preferred_names(global_var).first, global_var)
           end
@@ -113,6 +97,32 @@ module RuboCop
 
         private
 
+        def format_english_message(global_var)
+          regular, english = ENGLISH_VARS[global_var].partition do |var|
+            NON_ENGLISH_VARS.include? var
+          end
+
+          format_message(english, regular, global_var)
+        end
+
+        def format_message(english, regular, global_var)
+          if !regular.empty? && !english.empty?
+            format(MSG_BOTH, format_list(english), format_list(regular),
+                   global_var)
+          elsif !regular.empty?
+            format(MSG_REGULAR, format_list(regular), global_var)
+          elsif !english.empty?
+            format(MSG_ENGLISH, format_list(english), global_var)
+          else
+            raise 'Bug in SpecialGlobalVars - global var w/o preferred vars!'
+          end
+        end
+
+        # For now, we assume that lists are 2 items or less. Easy grammar!
+        def format_list(items)
+          items.join('` or `')
+        end
+
         def replacement(node, global_var)
           parent_type = node.parent && node.parent.type
           preferred_name = preferred_names(global_var).first

data/lib/rubocop/cop/style/unless_else.rb

@@ -14,7 +14,7 @@ module RuboCop
 
           # discard ternary ops and modifier if/unless nodes
           return unless loc.respond_to?(:keyword) && loc.respond_to?(:else)
-          return unless loc.keyword.is?('unless') && loc.else
+          return unless loc.keyword.is?('unless'.freeze) && loc.else
 
           add_offense(node, :expression)
         end

data/lib/rubocop/cop/team.rb

@@ -70,6 +70,24 @@ module RuboCop
         end
       end
 
+      def autocorrect(buffer, cops)
+        @updated_source_file = false
+        return unless autocorrect?
+
+        new_source = autocorrect_all_cops(buffer, cops)
+
+        return if new_source == buffer.source
+
+        if @options[:stdin]
+          # holds source read in from stdin, when --stdin option is used
+          @options[:stdin] = new_source
+        else
+          filename = buffer.name
+          File.open(filename, 'wb') { |f| f.write(new_source) }
+        end
+        @updated_source_file = true
+      end
+
       private
 
       def offenses(processed_source)
@@ -111,24 +129,6 @@ module RuboCop
           (@options[:only] || []).include?(cop_class.cop_name)
       end
 
-      def autocorrect(buffer, cops)
-        @updated_source_file = false
-        return unless autocorrect?
-
-        new_source = autocorrect_all_cops(buffer, cops)
-
-        return if new_source == buffer.source
-
-        if @options[:stdin]
-          # holds source read in from stdin, when --stdin option is used
-          @options[:stdin] = new_source
-        else
-          filename = buffer.name
-          File.open(filename, 'wb') { |f| f.write(new_source) }
-        end
-        @updated_source_file = true
-      end
-
       def autocorrect_all_cops(buffer, cops)
         corrector = Corrector.new(buffer)
         skip = Set.new

data/lib/rubocop/cop/util.rb

@@ -25,7 +25,7 @@ module RuboCop
 
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
-      LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGkwWszZS0-9]/
+      LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZS0-9]/
 
       module_function
 
@@ -151,7 +151,7 @@ module RuboCop
       def move_pos(src, pos, step, condition, regexp)
         offset = step == -1 ? -1 : 0
         pos += step while condition && src[pos + offset] =~ regexp
-        pos
+        pos < 0 ? 0 : pos
       end
 
       def directions(side)

data/lib/rubocop/node_pattern.rb

@@ -177,28 +177,42 @@ module RuboCop
       end
 
       def compile_seq_terms(tokens, cur_node)
-        terms = []
+        terms, size =
+          compile_seq_terms_with_size(tokens, cur_node) do |token, terms, index|
+            case token
+            when '...'.freeze
+              return compile_ellipsis(tokens, cur_node, terms, index)
+            when '$...'.freeze
+              return compile_capt_ellip(tokens, cur_node, terms, index)
+            end
+          end
+
+        terms << "(#{cur_node}.children.size == #{size})"
+      end
+
+      def compile_seq_terms_with_size(tokens, cur_node)
         index = nil
+        terms = []
         until tokens.first == ')'
-          if tokens.first == '...'
-            return compile_ellipsis(tokens, cur_node, terms, index || 0)
-          elsif tokens.first == '$...'
-            return compile_capt_ellip(tokens, cur_node, terms, index || 0)
-          elsif index.nil?
-            # in 'sequence head' position; some expressions are compiled
-            # differently at 'sequence head' (notably 'node type' expressions)
-            # grep for seq_head to see where it makes a difference
-            terms << compile_expr(tokens, cur_node, true)
-            index = 0
-          else
-            child_node = "#{cur_node}.children[#{index}]"
-            terms << compile_expr(tokens, child_node, false)
-            index += 1
-          end
+          yield tokens.first, terms, index || 0
+          term, index = compile_expr_with_index(tokens, cur_node, index)
+          terms << term
         end
-        terms << "(#{cur_node}.children.size == #{index})"
+
         tokens.shift # drop concluding )
-        terms
+        [terms, index]
+      end
+
+      def compile_expr_with_index(tokens, cur_node, index)
+        if index.nil?
+          # in 'sequence head' position; some expressions are compiled
+          # differently at 'sequence head' (notably 'node type' expressions)
+          # grep for seq_head to see where it makes a difference
+          [compile_expr(tokens, cur_node, true), 0]
+        else
+          child_node = "#{cur_node}.children[#{index}]"
+          [compile_expr(tokens, child_node, false), index + 1]
+        end
       end
 
       def compile_ellipsis(tokens, cur_node, terms, index)

data/lib/rubocop/processed_source.rb

@@ -103,7 +103,7 @@ module RuboCop
       @tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
     end
 
-    def parser_class(ruby_version)
+    def parser_class(ruby_version) # rubocop:disable Metrics/MethodLength
       case ruby_version
       when 1.9
         require 'parser/ruby19'

data/lib/rubocop/runner.rb

@@ -107,13 +107,20 @@ module RuboCop
           if cop.relevant_file?(file)
             cop.check(offenses, source.disabled_line_ranges, source.comments)
             offenses += cop.offenses
+            autocorrect_unneeded_disables(source, cop)
           end
         end
+        offenses
       end
 
       offenses.sort.reject(&:disabled?).freeze
     end
 
+    def autocorrect_unneeded_disables(source, cop)
+      cop.processed_source = source
+      Cop::Team.new([], nil, @options).autocorrect(source.buffer, [cop])
+    end
+
     def file_started(file)
       formatter_set.file_started(file,
                                  cli_options: @options,

data/lib/rubocop/version.rb

@@ -4,7 +4,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.41.1'.freeze
+    STRING = '0.41.2'.freeze
 
     MSG = '%s (using Parser %s, running on %s %s %s)'.freeze
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 0.41.1
+  version: 0.41.2
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-26 00:00:00.000000000 Z
+date: 2016-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rainbow
@@ -555,7 +555,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Automatic Ruby code style checking tool.