rubocop 0.20.1 → 0.21.0

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

@@ -15,7 +15,7 @@ module Rubocop
             true
           end
 
-          def deltas_for_first_pair(*_)
+          def deltas_for_first_pair(*)
             {} # The first pair is always considered correct.
           end
 
@@ -35,7 +35,7 @@ module Rubocop
             !any_pairs_on_the_same_line?(node) && all_have_same_sparator?(node)
           end
 
-          def deltas(first_pair, prev_pair, current_pair)
+          def deltas(first_pair, _prev_pair, current_pair)
             key_delta = key_delta(first_pair, current_pair)
             current_separator = current_pair.loc.operator
             separator_delta = separator_delta(first_pair, current_separator,
@@ -117,7 +117,7 @@ module Rubocop
 
         # Handles calculation of deltas when the enforced style is 'separator'.
         class SeparatorAlignment < AlignmentOfValues
-          def deltas_for_first_pair(first_pair, node)
+          def deltas_for_first_pair(*)
             {} # The first pair is always considered correct.
           end
 

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

@@ -52,11 +52,11 @@ module Rubocop
         end
 
         def check_compact_style(node, body)
-          return unless one_child?(node, body) && !compact_node_name?(node)
+          return unless one_child?(body) && !compact_node_name?(node)
           add_offense(node, :name, COMPACT_MSG)
         end
 
-        def one_child?(node, body)
+        def one_child?(body)
           body && body.type != :begin
         end
 

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

@@ -9,11 +9,11 @@ module Rubocop
         MSG = 'Do not use `::` for method calls.'
 
         def on_send(node)
-          receiver, _method_name, *_args = *node
+          receiver, method_name, *_args = *node
 
           # discard methods with nil receivers and op methods(like [])
           return unless receiver && node.loc.dot && node.loc.dot.is?('::')
-          return if allowed_name(_method_name.to_s)
+          return if allowed_name(method_name.to_s)
 
           add_offense(node, :dot)
         end

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

@@ -19,7 +19,7 @@ module Rubocop
 
         private
 
-        def message(node)
+        def message(_node)
           'Place the . on the ' +
             case style
             when :leading

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

@@ -3,27 +3,55 @@
 module Rubocop
   module Cop
     module Style
-      # This cop checks whether the source file has a
-      # utf-8 encoding comment. This check makes sense only
-      # in Ruby 1.9, since in 2.0+ utf-8 is the default source file
-      # encoding.
+      # This cop checks whether the source file has a utf-8 encoding comment or
+      # not. This check makes sense only in Ruby 1.9, since in 2.0+ utf-8 is
+      # the default source file encoding. There are two style:
+      #
+      # when_needed - only enforce an encoding comment if there are non ASCII
+      #               characters, otherwise report an offense
+      # always - enforce encoding comment in all files
       class Encoding < Cop
-        MSG = 'Missing utf-8 encoding comment.'
+        include ConfigurableEnforcedStyle
+
+        MSG_MISSING = 'Missing utf-8 encoding comment.'
+        MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
 
         def investigate(processed_source)
-          unless RUBY_VERSION >= '2.0.0'
-            line_number = 0
-            line_number += 1 if processed_source[line_number] =~ /^#!/
-            line = processed_source[line_number]
-            unless line =~ /#.*coding\s?[:=]\s?(UTF|utf)-8/
-              add_offense(nil,
-                          source_range(processed_source.buffer,
-                                       processed_source[0...line_number],
-                                       0, 1),
-                          MSG)
-            end
+          return if RUBY_VERSION >= '2.0.0'
+          return if processed_source.buffer.source.empty?
+
+          line_number = encoding_line_number(processed_source)
+          message = offense(processed_source, line_number)
+
+          if message
+            add_offense(nil,
+                        source_range(processed_source.buffer,
+                                     processed_source[0...line_number],
+                                     0, 1),
+                        message)
+          end
+        end
+
+        private
+
+        def offense(processed_source, line_number)
+          line = processed_source[line_number]
+          encoding_present = line =~ /#.*coding\s?[:=]\s?(UTF|utf)-8/
+          ascii_only = processed_source.buffer.source.ascii_only?
+          always_encode = style == :always
+
+          if !encoding_present && (always_encode || !ascii_only)
+            MSG_MISSING
+          elsif !always_encode && ascii_only && encoding_present
+            MSG_UNNECESSARY
           end
         end
+
+        def encoding_line_number(processed_source)
+          line_number = 0
+          line_number += 1 if processed_source[line_number] =~ /^#!/
+          line_number
+        end
       end
     end
   end

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

@@ -27,8 +27,10 @@ module Rubocop
         def on_block(node)
           _method, _args, body = *node
           # Check body against end/} indentation. Checking against variable
-          # assignments, etc, would be more difficult.
-          check_indentation(node.loc.end, body)
+          # assignments, etc, would be more difficult. The end/} must be at the
+          # beginning of its line.
+          loc = node.loc
+          check_indentation(loc.end, body) if begins_its_line?(loc.end)
         end
 
         def on_module(node)
@@ -41,8 +43,19 @@ module Rubocop
           members.each { |m| check_indentation(node.loc.keyword, m) }
         end
 
+        def on_send(node)
+          super
+          receiver, method_name, *args = *node
+
+          if visibility_and_def_on_same_line?(receiver, method_name, args)
+            _method_name, _args, body = *args.first
+            check_indentation(node.loc.expression, body)
+            ignore_node(args.first)
+          end
+        end
+
         def check(node, _method_name, _args, body)
-          check_indentation(node.loc.keyword, body)
+          check_indentation(node.loc.keyword, body) unless ignored_node?(node)
         end
 
         def on_for(node)
@@ -92,6 +105,11 @@ module Rubocop
 
         private
 
+        def begins_its_line?(range)
+          source_before_end = range.source_buffer.source[0...range.begin_pos]
+          source_before_end =~ /\n\s*\Z/
+        end
+
         def check_assignment(node, rhs)
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before
@@ -99,12 +117,8 @@ module Rubocop
           rhs = first_part_of_call_chain(rhs)
 
           if rhs
-            end_alignment_config = config.for_cop('EndAlignment')
-            style = if end_alignment_config['Enabled']
-                      end_alignment_config['AlignWith']
-                    else
-                      'keyword'
-                    end
+            end_config = config.for_cop('EndAlignment')
+            style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
             base = style == 'variable' ? node : rhs
 
             case rhs.type
@@ -141,7 +155,7 @@ module Rubocop
           return if starts_with_access_modifier?(body_node)
 
           # Don't check indentation if the line doesn't start with the body.
-          # For example lines like "else do_something".
+          # For example, lines like "else do_something".
           first_char_pos_on_line = body_node.loc.expression.source_line =~ /\S/
           return unless body_node.loc.column == first_char_pos_on_line
 
@@ -154,15 +168,11 @@ module Rubocop
           body_node = body_node.children.first if body_node.type == :begin
 
           expr = body_node.loc.expression
-          pos = if indentation >= 0
-                  (expr.begin_pos - indentation)..expr.begin_pos
-                else
-                  expr.begin_pos..(expr.begin_pos - indentation)
-                end
-
-          add_offense(body_node,
-                      Parser::Source::Range.new(expr.source_buffer,
-                                                pos.begin, pos.end),
+          begin_pos, ind = expr.begin_pos, expr.begin_pos - indentation
+          pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
+
+          r = Parser::Source::Range.new(expr.source_buffer, pos.begin, pos.end)
+          add_offense(body_node, r,
                       format("Use #{CORRECT_INDENTATION} (not %d) spaces " \
                              'for indentation.', indentation))
         end

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

@@ -50,7 +50,7 @@ module Rubocop
           end
         end
 
-        def message(node)
+        def message(_node)
           if style == :call
             'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
           else

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

@@ -20,7 +20,7 @@ module Rubocop
       #              'bala'
       #
       class LineEndConcatenation < Cop
-        MSG = 'Use \\ instead of + to concatenate those strings.'
+        MSG = 'Use \\ instead of + or << to concatenate those strings.'
 
         def on_send(node)
           add_offense(node, :selector) if offending_node?(node)

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

@@ -3,8 +3,10 @@
 module Rubocop
   module Cop
     module Style
-      # This cop enforces the consitent useage of `%`-literal delimiters.
+      # This cop enforces the consistent usage of `%`-literal delimiters.
       class PercentLiteralDelimiters < Cop
+        include PercentLiteral
+
         def on_array(node)
           process(node, '%w', '%W', '%i')
         end
@@ -57,16 +59,6 @@ module Rubocop
           end
         end
 
-        def process(node, *types)
-          on_percent_literal(node, types) if percent_literal?(node)
-        end
-
-        def percent_literal?(node)
-          if (begin_source = begin_source(node))
-            begin_source.start_with?('%')
-          end
-        end
-
         def on_percent_literal(node, types)
           type = type(node)
           if types.include?(type) &&
@@ -76,10 +68,6 @@ module Rubocop
           end
         end
 
-        def type(node)
-          node.loc.begin.source[0..-2]
-        end
-
         def preferred_delimiters(type)
           cop_config['PreferredDelimiters'][type].split(//)
         end
@@ -125,12 +113,6 @@ module Rubocop
             .any? { |s| preferred_delimiters.any? { |d| s.include?(d) } }
         end
 
-        def begin_source(node)
-          if node.loc.respond_to?(:begin) && node.loc.begin
-            node.loc.begin.source
-          end
-        end
-
         def string_source(node)
           if node.is_a?(String)
             node

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

@@ -22,7 +22,7 @@ module Rubocop
 
         private
 
-        def check(node, method_name, args, _body)
+        def check(node, method_name, _args, _body)
           prefix_blacklist.each do |prefix|
             if method_name.to_s.start_with?(prefix)
               add_offense(node, :name,

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

@@ -58,7 +58,7 @@ module Rubocop
           when :compact
             "Provide an exception object as an argument to `#{method}`."
           when :exploded
-            "Provide an exception class and message as " \
+            'Provide an exception class and message as ' \
             "arguments to `#{method}`."
           end
         end

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

@@ -22,13 +22,29 @@ module Rubocop
 
         MSG = 'Redundant `begin` block detected.'
 
-        private
-
         def check(_node, _method_name, _args, body)
           return unless body && body.type == :kwbegin
 
           add_offense(body, :begin)
         end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            child = node.children.first
+
+            begin_indent = node.loc.column
+            child_indent = child.loc.column
+
+            indent_diff = child_indent - begin_indent
+
+            corrector.replace(
+              range_with_surrounding_space(node.loc.expression),
+              range_with_surrounding_space(
+                child.loc.expression
+              ).source.gsub(/^\s{#{indent_diff}}/, '')
+            )
+          end
+        end
       end
     end
   end

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

@@ -67,11 +67,11 @@ module Rubocop
 
         # Using self.x to distinguish from local variable x
 
-        def on_def(node)
+        def on_def(_node)
           @local_variables = []
         end
 
-        def on_defs(node)
+        def on_defs(_node)
           @local_variables = []
         end
 

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

@@ -11,17 +11,17 @@ module Rubocop
           string_parts = node.children.select { |child| child.type == :str }
           total_string = string_parts.map { |s| s.loc.expression.source }.join
           slashes = total_string.count('/')
-          if node.loc.begin.is?('/')
+          delimiter_start = node.loc.begin.source[0]
+
+          if delimiter_start == '/'
             if slashes > max_slashes
-              add_offense(node, :expression, error_message('')) do
-                self.slash_count_in_slashes_regexp = slashes
-              end
+              add_offense(node, :expression, error_message(''))
             end
           elsif slashes <= max_slashes
-            add_offense(node, :expression, error_message('only ')) do
-              self.slash_count_in_percent_r_regexp = slashes
-            end
+            add_offense(node, :expression, error_message('only '))
           end
+
+          configure_max(delimiter_start, slashes) if @options[:auto_gen_config]
         end
 
         private
@@ -34,38 +34,30 @@ module Rubocop
           m
         end
 
-        # MaxSlashes must be set equal to the highest number of slashes used
-        # within // to avoid reports.
-        def slash_count_in_slashes_regexp=(value)
-          configure_slashes(value) { |current| [current, value].max }
-        end
-
-        # MaxSlashes must be set one less than the highest number of slashes
-        # used within %r{} to avoid reports.
-        def slash_count_in_percent_r_regexp=(value)
-          configure_slashes(value - 1) { |current| [current, value - 1].min }
-        end
+        def configure_max(delimiter_start, value)
+          @slash_count ||= { '/' => Set.new([0]), '%' => Set.new([100_000]) }
+          @slash_count[delimiter_start].add(value)
 
-        def configure_slashes(value)
-          cfg = self.config_to_allow_offenses ||= {}
-          return if cfg.key?('Enabled')
+          # To avoid reports, MaxSlashes must be set equal to the highest
+          # number of slashes used within //, and also one less than the
+          # highest number of slashes used within %r{}. If no value can satisfy
+          # both requirements, just disable.
+          max = @slash_count['/'].max
+          min = @slash_count['%'].min
 
-          if cfg['MaxSlashes']
-            value = yield cfg['MaxSlashes']
-            if cfg['MaxSlashes'] > max_slashes && value < max_slashes ||
-                cfg['MaxSlashes'] < max_slashes && value > max_slashes
-              # We can't both increase and decrease MaxSlashes to avoid
-              # reports. This means that the only option is to disable the cop.
-              cfg = self.config_to_allow_offenses = { 'Enabled' => false }
-              return
-            end
-          end
-
-          if value >= 0
-            cfg['MaxSlashes'] = value
-          else
-            self.config_to_allow_offenses = { 'Enabled' => false }
-          end
+          self.config_to_allow_offenses = if max > max_slashes
+                                            if max < min
+                                              { 'MaxSlashes' => max }
+                                            else
+                                              { 'Enabled' => false }
+                                            end
+                                          elsif min < max_slashes + 1
+                                            if max < min
+                                              { 'MaxSlashes' => min - 1 }
+                                            else
+                                              { 'Enabled' => false }
+                                            end
+                                          end
         end
 
         def error_message(word)