rubocop 0.20.1 → 0.21.0

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

@@ -18,7 +18,7 @@ module Rubocop
         MSG = 'Never put a space between a method name and the opening ' \
               'parenthesis.'
 
-        def check(_node, _method_name, args, body)
+        def check(_node, _method_name, args, _body)
           return unless args.loc.begin && args.loc.begin.is?('(')
           expr = args.loc.expression
           pos_before_left_paren = Parser::Source::Range.new(expr.source_buffer,

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

@@ -10,7 +10,7 @@ module Rubocop
 
         private
 
-        def message(node)
+        def message(*)
           if style == :single_quotes
             "Prefer single-quoted strings when you don't need string " \
             'interpolation or special symbols.'

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

@@ -3,40 +3,54 @@
 module Rubocop
   module Cop
     module Style
-      # This cop looks for trailing blank lines in the source code.
+      # This cop looks for trailing blank lines and a final newline in the
+      # source code.
       class TrailingBlankLines < Cop
-        MSG = '%d trailing blank lines detected.'
+        include ConfigurableEnforcedStyle
 
         def investigate(processed_source)
-          blank_lines = 0
+          sb = processed_source.buffer
+          return if sb.source.empty?
 
-          processed_source.lines.reverse_each do |line|
-            if line.blank?
-              blank_lines += 1
-            else
-              break
-            end
+          whitespace_at_end = sb.source[/\s*\Z/]
+          blank_lines = whitespace_at_end.count("\n") - 1
+          wanted_blank_lines = style == :final_newline ? 0 : 1
+
+          if blank_lines != wanted_blank_lines
+            begin_pos = sb.source.length - whitespace_at_end.length
+            autocorrect_range = Parser::Source::Range.new(sb, begin_pos,
+                                                          sb.source.length)
+            begin_pos += "\n".length unless whitespace_at_end.length == 0
+            report_range = Parser::Source::Range.new(sb, begin_pos,
+                                                     sb.source.length)
+            add_offense(autocorrect_range, report_range,
+                        message(wanted_blank_lines, blank_lines))
           end
+        end
 
-          if blank_lines > 0
-            range_size =
-              processed_source.raw_lines.to_a[-blank_lines..-1].join.length
-            range = source_range(processed_source.buffer,
-                                 processed_source[0...-blank_lines],
-                                 0, range_size)
-            add_offense(range, range, format(MSG, blank_lines))
+        private
+
+        def message(wanted_blank_lines, blank_lines)
+          case blank_lines
+          when -1
+            'Final newline missing.'
+          when 0
+            'Trailing blank line missing.'
+          else
+            instead_of = if wanted_blank_lines == 0
+                           ''
+                         else
+                           "instead of #{wanted_blank_lines} "
+                         end
+            format('%d trailing blank lines %sdetected.', blank_lines,
+                   instead_of)
           end
         end
 
         def autocorrect(range)
-          # Bail out if there's also trailing whitespace, because
-          # auto-correction in the two cops would result in clobbering.
-          if range.source =~ / / &&
-              config.for_cop('TrailingWhitespace')['Enabled']
-            return
+          @corrections << lambda do |corrector|
+            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
           end
-
-          @corrections << ->(corrector) { corrector.remove(range) }
         end
       end
     end

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

@@ -56,8 +56,7 @@ module Rubocop
           should_have_comma = style == :comma && multiline?(node)
           if comma_offset
             unless should_have_comma
-              avoid_comma(items, kind,
-                          after_last_item.begin_pos + comma_offset, sb)
+              avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb)
             end
           elsif should_have_comma
             put_comma(items, kind, sb)
@@ -79,7 +78,7 @@ module Rubocop
           [node.loc.begin, node.loc.end].map(&:line).uniq.size > 1
         end
 
-        def avoid_comma(items, kind, comma_begin_pos, sb)
+        def avoid_comma(kind, comma_begin_pos, sb)
           range = Parser::Source::Range.new(sb, comma_begin_pos,
                                             comma_begin_pos + 1)
           article = kind =~ /array/ ? 'an' : 'a'

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

@@ -32,6 +32,10 @@ module Rubocop
           cop_config['AllowPredicates']
         end
 
+        def allow_dsl_writers?
+          cop_config['AllowDSLWriters']
+        end
+
         def whitelist
           whitelist = cop_config['Whitelist']
           Array(whitelist).map(&:to_sym) + [:initialize]
@@ -41,9 +45,14 @@ module Rubocop
           method_name[-1] == '?'
         end
 
+        def dsl_writer?(method_name)
+          !method_name.to_s.end_with?('=')
+        end
+
         def trivial_reader?(method_name, args, body)
           looks_like_trivial_reader?(args, body) &&
-            !allowed_method?(method_name, body)
+            !allowed_method?(method_name, body) &&
+            !allowed_reader?(method_name)
         end
 
         def looks_like_trivial_reader?(args, body)
@@ -52,7 +61,8 @@ module Rubocop
 
         def trivial_writer?(method_name, args, body)
           looks_like_trivial_writer?(args, body) &&
-            !allowed_method?(method_name, body)
+            !allowed_method?(method_name, body) &&
+            !allowed_writer?(method_name)
         end
 
         def looks_like_trivial_writer?(args, body)
@@ -62,16 +72,42 @@ module Rubocop
         end
 
         def allowed_method?(method_name, body)
-          allow_predicates? && predicate?(method_name) ||
-            whitelist.include?(method_name) ||
+          whitelist.include?(method_name) ||
             exact_name_match? && !names_match?(method_name, body)
         end
 
+        def allowed_writer?(method_name)
+          allow_dsl_writers? && dsl_writer?(method_name)
+        end
+
+        def allowed_reader?(method_name)
+          allow_predicates? && predicate?(method_name)
+        end
+
         def names_match?(method_name, body)
           ivar_name, = *body
 
           method_name.to_s.chomp('=') == ivar_name[1..-1]
         end
+
+        def autocorrect(node)
+          method_name, args, body = *node
+          return unless node.type == :def
+          return unless names_match?(method_name, body)
+          kind = if trivial_writer?(method_name, args, body)
+                   return if dsl_writer?(method_name)
+                   'writer'
+                 elsif trivial_reader?(method_name, args, body)
+                   'reader'
+                 end
+
+          @corrections << lambda do |corrector|
+            corrector.replace(
+              node.loc.expression,
+              "attr_#{kind} :#{method_name.to_s.chomp('=')}"
+            )
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for usage of the %W() syntax when %w() would do.
+      class UnneededCapitalW < Cop
+        include PercentLiteral
+
+        MSG =
+          'Do not use `%W` unless interpolation is needed.  If not, use `%w`.'
+
+        def on_array(node)
+          process(node, '%W')
+        end
+
+        private
+
+        def on_percent_literal(node, types)
+          type = type(node)
+          if types.include?(type) &&
+            node.children.none? { |x| x.type == :dstr }
+            add_offense(node, :expression)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/team.rb

@@ -32,7 +32,7 @@ module Rubocop
           return Lint::Syntax.offenses_from_diagnostics(diagnostics)
         end
 
-        commissioner = Commissioner.new(cops)
+        commissioner = Commissioner.new(cops, forces)
         offenses = commissioner.investigate(processed_source)
         process_commissioner_errors(
           processed_source.file_path, commissioner.errors)
@@ -50,11 +50,19 @@ module Rubocop
         end
       end
 
+      def forces
+        @forces ||= Force.all.each_with_object([]) do |force_class, forces|
+          joining_cops = cops.select { |cop| cop.join_force?(force_class) }
+          next if joining_cops.empty?
+          forces << force_class.new(joining_cops)
+        end
+      end
+
       private
 
       def cop_enabled?(cop_class)
         @config.cop_enabled?(cop_class) ||
-          cop_class.cop_name == @options[:only]
+          (@options[:only] || []).include?(cop_class.cop_name)
       end
 
       def autocorrect(buffer, cops)

data/lib/rubocop/cop/util.rb

@@ -144,8 +144,8 @@ module Rubocop
         Parser::Source::Range.new(@processed_source.buffer, begin_pos, end_pos)
       end
 
-      # Returns for example a bare `if` node if the given node is an `if` whith
-      # calls chained to the end of it.
+      # Returns, for example, a bare `if` node if the given node is an `if`
+      # with calls chained to the end of it.
       def first_part_of_call_chain(node)
         while node
           case node.type

data/lib/rubocop/cop/{variable_inspector.rb → variable_force.rb}

@@ -2,23 +2,37 @@
 
 module Rubocop
   module Cop
-    # This module provides a way to track local variables and scopes of Ruby.
-    # This is intended to be used as mix-in, and the user class may override
-    # some of the hook methods.
-    module VariableInspector
+    # This force provides a way to track local variables and scopes of Ruby.
+    # Cops intertact with this force need to override some of the hook methods.
+    #
+    #     def before_entering_scope(scope, variable_table)
+    #     end
+    #
+    #     def after_entering_scope(scope, variable_table)
+    #     end
+    #
+    #     def before_leaving_scope(scope, variable_table)
+    #     end
+    #
+    #     def after_leaving_scope(scope, variable_table)
+    #     end
+    #
+    #     def before_declaring_variable(variable, variable_table)
+    #     end
+    #
+    #     def after_declaring_variable(variable, variable_table)
+    #     end
+    class VariableForce < Force # rubocop:disable ClassLength
       VARIABLE_ASSIGNMENT_TYPE = :lvasgn
       REGEXP_NAMED_CAPTURE_TYPE = :match_with_lvasgn
       VARIABLE_ASSIGNMENT_TYPES =
         [VARIABLE_ASSIGNMENT_TYPE, REGEXP_NAMED_CAPTURE_TYPE].freeze
 
-      METHOD_ARGUMENT_DECLARATION_TYPES = [
+      ARGUMENT_DECLARATION_TYPES = [
         :arg, :optarg, :restarg,
-        :kwarg, :kwoptarg, :kwrestarg
+        :kwarg, :kwoptarg, :kwrestarg,
+        :blockarg # This doen't mean block argument, it's block-pass (&block).
       ].freeze
-      BLOCK_ARGUMENT_DECLARATION_TYPE = :blockarg
-      ARGUMENT_DECLARATION_TYPES = (
-        METHOD_ARGUMENT_DECLARATION_TYPES + [BLOCK_ARGUMENT_DECLARATION_TYPE]
-      ).freeze
       BLOCK_LOCAL_VARIABLE_DECLARATION_TYPE = :shadowarg
       DECLARATION_TYPES = (
         ARGUMENT_DECLARATION_TYPES + [BLOCK_LOCAL_VARIABLE_DECLARATION_TYPE]
@@ -42,27 +56,26 @@ module Rubocop
       TWISTED_SCOPE_TYPES = [:block, :class, :sclass, :defs].freeze
       SCOPE_TYPES = (TWISTED_SCOPE_TYPES + [:top_level, :module, :def]).freeze
 
+      def self.wrap_with_top_level_node(node)
+        # This is a custom node type, not defined in Parser.
+        Parser::AST::Node.new(:top_level, [node])
+      end
+
       def variable_table
         @variable_table ||= VariableTable.new(self)
       end
 
       # Starting point.
-      def inspect_variables(root_node)
+      def investigate(processed_source)
+        root_node = processed_source.ast
         return unless root_node
 
         # Wrap the root node with :top_level scope node.
-        top_level_node = wrap_with_top_level_node(root_node)
+        top_level_node = self.class.wrap_with_top_level_node(root_node)
 
         inspect_variables_in_scope(top_level_node)
       end
 
-      def wrap_with_top_level_node(node)
-        # This is a custom node type, not defined in Parser.
-        Parser::AST::Node.new(:top_level, [node])
-      end
-
-      module_function :wrap_with_top_level_node
-
       # This is called for each scope recursively.
       def inspect_variables_in_scope(scope_node)
         variable_table.push_scope(scope_node)
@@ -339,24 +352,19 @@ module Rubocop
         @scanned_nodes ||= []
       end
 
-      # Hooks
-
-      def before_entering_scope(scope)
-      end
-
-      def after_entering_scope(scope)
-      end
-
-      def before_leaving_scope(scope)
-      end
-
-      def after_leaving_scope(scope)
-      end
-
-      def before_declaring_variable(variable_variable)
-      end
-
-      def after_declaring_variable(variable_variable)
+      # Hooks invoked by VariableTable.
+      [
+        :before_entering_scope,
+        :after_entering_scope,
+        :before_leaving_scope,
+        :after_leaving_scope,
+        :before_declaring_variable,
+        :after_declaring_variable
+      ].each do |hook|
+        define_method(hook) do |arg|
+          # Invoke hook in cops.
+          run_hook(hook, arg, variable_table)
+        end
       end
 
       # Post condition loops

data/lib/rubocop/cop/{variable_inspector → variable_force}/assignment.rb

@@ -2,7 +2,7 @@
 
 module Rubocop
   module Cop
-    module VariableInspector
+    class VariableForce
       # This class represents each assignment of a variable.
       class Assignment
         include Locatable

data/lib/rubocop/cop/{variable_inspector → variable_force}/locatable.rb

@@ -2,7 +2,7 @@
 
 module Rubocop
   module Cop
-    module VariableInspector
+    class VariableForce
       # This module provides a way to locate the conditional branch the node is
       # in. This is intended to be used as mix-in.
       module Locatable

data/lib/rubocop/cop/{variable_inspector → variable_force}/reference.rb

@@ -2,7 +2,7 @@
 
 module Rubocop
   module Cop
-    module VariableInspector
+    class VariableForce
       # This class represents each reference of a variable.
       class Reference
         include Locatable
@@ -25,6 +25,18 @@ module Rubocop
           @node = node
           @scope = scope
         end
+
+        # There's an implicit variable reference by the zero-arity `super`:
+        #
+        #     def some_method(foo)
+        #       super
+        #     end
+        #
+        # In this case, the variable `foo` is not explicitly referenced,
+        # but it can be considered used implicitly by the `super`.
+        def explicit?
+          @node.type != ZERO_ARITY_SUPER_TYPE
+        end
       end
     end
   end

data/lib/rubocop/cop/{variable_inspector → variable_force}/scope.rb

@@ -2,7 +2,7 @@
 
 module Rubocop
   module Cop
-    module VariableInspector
+    class VariableForce
       # A Scope represents a context of local variable visibility.
       # This is a place where local variables belong to.
       # A scope instance holds a scope node and variable entries.
@@ -24,6 +24,14 @@ module Rubocop
           @node.equal?(other.node)
         end
 
+        def name
+          case @node.type
+          when :def  then @node.children[0]
+          when :defs then @node.children[1]
+          else nil # TODO
+          end
+        end
+
         def body_node
           child_index = case @node.type
                         when :top_level           then 0