rubocop 0.15.0 → 0.16.0

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

@@ -16,7 +16,7 @@ module Rubocop
             index = index_of_first_token(optarg)
             arg, equals, value = processed_source.tokens[index, 3]
             unless space_between?(arg, equals) && space_between?(equals, value)
-              convention(equals.pos, equals.pos)
+              add_offence(equals.pos, equals.pos)
             end
           end
         end

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

@@ -6,150 +6,65 @@ module Rubocop
       # Checks that operators have space around them, except for **
       # which should not have surrounding space.
       class SpaceAroundOperators < Cop
-        include SurroundingSpace
-        MSG_MISSING = "Surrounding space missing for operator '%s'."
-        MSG_DETECTED = 'Space around operator ** detected.'
+        TYPES = %w(and or class
+                   op_asgn and_asgn or_asgn masgn casgn lvasgn ivasgn gvasgn)
 
-        # rubocop:disable SymbolName
-        BINARY_OPERATORS =
-          [:tEQL,    :tAMPER2,  :tPIPE,  :tCARET, :tPLUS,  :tMINUS, :tSTAR2,
-           :tDIVIDE, :tPERCENT, :tEH,    :tCOLON, :tANDOP, :tOROP,  :tMATCH,
-           :tNMATCH, :tEQ,      :tNEQ,   :tGT,    :tRSHFT, :tGEQ,   :tLT,
-           :tLSHFT,  :tLEQ,     :tASSOC, :tEQQ,   :tCMP,   :tOP_ASGN]
+        TYPES.each { |t| define_method(:"on_#{t}") { |node| check(node) } }
 
-        def investigate(processed_source)
-          return unless processed_source.ast
-          @processed_source = processed_source
-          tokens = processed_source.tokens
-          tokens.each_cons(3) do |token_before, token, token_after|
-            next if token_before.type == :kDEF # TODO: remove?
-            next if token_before.type == :tDOT # Called as method.
-            next if positions_not_to_check.include?(token.pos)
-
-            case token.type
-            when :tPOW, :tDSTAR
-              if space_on_any_side?(token_before, token, token_after)
-                convention(token_with_surrounding_space(token), token.pos,
-                           MSG_DETECTED)
-              end
-            when *BINARY_OPERATORS
-              check_missing_space(token_before, token, token_after)
-            end
-          end
-        end
-
-        # Returns an array of positions marking the tokens that this cop
-        # should not check, either because the token is not an operator
-        # or because another cop does the check.
-        def positions_not_to_check
-          @positions_not_to_check ||= begin
-            positions = []
-            positions.concat(do_not_check_block_arg_pipes)
-            positions.concat(do_not_check_param_default)
-            positions.concat(do_not_check_class_lshift_self)
-            positions.concat(do_not_check_def_things)
-            positions.concat(do_not_check_singleton_operator_defs)
-            positions
-          end
+        def on_pair(node)
+          check(node) if node.loc.operator.is?('=>')
         end
 
-        def do_not_check_block_arg_pipes
-          # each { |a| }
-          #        ^ ^
-          positions = []
-          on_node(:block, @processed_source.ast) do |b|
-            on_node(:args, b) do |a|
-              positions << a.loc.begin << a.loc.end if a.loc.begin
-            end
+        def on_if(node)
+          if node.loc.respond_to?(:question)
+            check_operator(node.loc.question)
+            check_operator(node.loc.colon)
           end
-          positions
         end
 
-        def do_not_check_param_default
-          # func(a, b=nil)
-          #          ^
-          positions = []
-          tokens = @processed_source.tokens
-          on_node(:optarg, @processed_source.ast) do |optarg|
-            _arg, equals, _value = tokens[index_of_first_token(optarg),
-                                          3]
-            positions << equals.pos
-          end
-          positions
+        def on_resbody(node)
+          check_operator(node.loc.assoc) if node.loc.assoc
         end
 
-        def do_not_check_class_lshift_self
-          # class <<self
-          #       ^
-          positions = []
-          tokens = @processed_source.tokens
-          on_node(:sclass, @processed_source.ast) do |sclass|
-            ix = index_of_first_token(sclass)
-            if tokens[ix, 2].map(&:type) == [:kCLASS, :tLSHFT]
-              positions << tokens[ix + 1].pos
-            end
+        def on_send(node)
+          if node.loc.operator
+            check(node)
+          elsif !unary_operation?(node) && !called_with_dot?(node)
+            op = node.loc.selector
+            check_operator(op) if operator?(op)
           end
-          positions
         end
 
-        def do_not_check_def_things
-          # def +(other)
-          #     ^
-          positions = []
-          tokens = @processed_source.tokens
-          on_node(:def, @processed_source.ast) do |def_node|
-            # def each &block
-            #          ^
-            # def each *args
-            #          ^
-            on_node([:blockarg, :restarg], def_node) do |arg_node|
-              positions << tokens[index_of_first_token(arg_node)].pos
-            end
-            positions << tokens[index_of_first_token(def_node) + 1].pos
-          end
-          positions
-        end
+        private
 
-        def do_not_check_singleton_operator_defs
-          # def self.===(other)
-          #          ^
-          positions = []
-          tokens = @processed_source.tokens
-          on_node(:defs, @processed_source.ast) do |defs_node|
-            _receiver, name, _args = *defs_node
-            ix = index_of_first_token(defs_node)
-            name_token = tokens[ix..-1].find { |t| t.text == name.to_s }
-            positions << name_token.pos
-          end
-          positions
+        def operator?(range)
+          range.source !~ /^\[|\w/
         end
 
-        def check_missing_space(token_before, token, token_after)
-          unless space_on_both_sides?(token_before, token, token_after)
-            text = token.text.to_s + (token.type == :tOP_ASGN ? '=' : '')
-            convention(token_with_surrounding_space(token), token.pos,
-                       MSG_MISSING.format(text))
-          end
+        def unary_operation?(node)
+          whole, selector = node.loc.expression, node.loc.selector
+          operator?(selector) && whole.begin_pos == selector.begin_pos
         end
 
-        def token_with_surrounding_space(token)
-          src = @processed_source.buffer.source
-          begin_pos = token.pos.begin_pos
-          begin_pos -= 1 while src[begin_pos - 1] =~ /[ \t]/
-          end_pos = token.pos.end_pos
-          end_pos += 1 while src[end_pos] =~ /[ \t]/
-          Parser::Source::Range.new(@processed_source.buffer, begin_pos,
-                                    end_pos)
+        def called_with_dot?(node)
+          !!node.loc.dot
         end
 
-        def space_on_both_sides?(token_before, token, token_after)
-          space_between?(token_before, token) && space_between?(token,
-                                                                token_after)
+        def check(node)
+          check_operator(node.loc.operator) if node.loc.operator
         end
 
-        def space_on_any_side?(token_before, token, token_after)
-          space_between?(token_before, token) || space_between?(token,
-                                                                token_after)
+        def check_operator(op)
+          with_space = range_with_surrounding_space(op)
+          if op.is?('**')
+            unless with_space.is?('**')
+              add_offence(with_space, op, 'Space around operator ** detected.')
+            end
+          elsif with_space.source !~ /^\s.*\s$/
+            add_offence(with_space, op,
+                        'Surrounding space missing for operator' +
+                        " '#{op.source}'.")
+          end
         end
 
         def autocorrect(range)

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

@@ -12,7 +12,7 @@ module Rubocop
             kw = node.loc.keyword
             b = kw.begin_pos
             left_of_kw = Parser::Source::Range.new(kw.source_buffer, b - 1, b)
-            convention(node, left_of_kw) unless left_of_kw.is?(' ')
+            add_offence(node, left_of_kw) unless left_of_kw.is?(' ')
           end
         end
 

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

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-# rubocop:disable SymbolName
-
 module Rubocop
   module Cop
     module Style
@@ -20,7 +18,7 @@ module Rubocop
                 range = Parser::Source::Range.new(processed_source.buffer,
                                                   t1.pos.end_pos,
                                                   t2.pos.begin_pos)
-                convention(range, range, format(MSG, kind))
+                add_offence(range, range, format(MSG, kind))
               end
             end
           end

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

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-# rubocop:disable SymbolName
-
 module Rubocop
   module Cop
     module Style

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

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-# rubocop:disable SymbolName
-
 module Rubocop
   module Cop
     module Style
@@ -9,6 +7,8 @@ module Rubocop
       # surrounding space depending on configuration.
       class SpaceInsideHashLiteralBraces < Cop
         include SurroundingSpace
+        include ConfigurableEnforcedStyle
+
         MSG = 'Space inside %s.'
 
         def investigate(processed_source)
@@ -35,13 +35,13 @@ module Rubocop
           expect_space = if is_empty_braces
                            cop_config['EnforcedStyleForEmptyBraces'] == 'space'
                          else
-                           cop_config['EnforcedStyle'] == 'space'
+                           style == :space
                          end
           if offence?(t1, t2, expect_space)
             brace = (t1.text == '{' ? t1 : t2).pos
             range = expect_space ? brace : space_range(brace)
-            convention(range, range,
-                       message(brace, is_empty_braces, expect_space))
+            add_offence(range, range,
+                        message(brace, is_empty_braces, expect_space))
           end
         end
 

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

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-# rubocop:disable SymbolName
-
 module Rubocop
   module Cop
     module Style

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

@@ -45,7 +45,7 @@ module Rubocop
         def on_gvar(node)
           global_var, = *node
 
-          convention(node, :expression) if PREFERRED_VARS[global_var]
+          add_offence(node, :expression) if PREFERRED_VARS[global_var]
         end
 
         def message(node)

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

@@ -14,7 +14,7 @@ module Rubocop
           return unless node.loc.respond_to?(:begin) && node.loc.begin
           return if part_of_ignored_node?(node)
 
-          convention(node, :expression) if offence?(node)
+          add_offence(node, :expression) if offence?(node)
         end
 
         def on_dstr(node)

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

@@ -5,12 +5,13 @@ module Rubocop
     module Style
       # Checks if uses of quotes match the configured preference.
       class StringLiterals < Cop
+        include ConfigurableEnforcedStyle
         include StringHelp
 
         private
 
         def message(node)
-          if single_quotes_preferred?
+          if style == :single_quotes
             "Prefer single-quoted strings when you don't need string " +
               'interpolation or special symbols.'
           else
@@ -21,8 +22,8 @@ module Rubocop
 
         def offence?(node)
           src = node.loc.expression.source
-          return false if src =~ /^(%q|\?)/i
-          src !~ if single_quotes_preferred?
+          return false if src =~ /^(%q|\?|<<-)/i
+          src !~ if style == :single_quotes
                    # regex matches IF there is a ' or there is a \\ in the
                    # string that is not preceeded/followed by another \\
                    # (e.g. "\\x34") but not "\\\\"
@@ -32,14 +33,6 @@ module Rubocop
                  end
         end
 
-        def single_quotes_preferred?
-          case cop_config['EnforcedStyle']
-          when 'single_quotes' then true
-          when 'double_quotes' then false
-          else fail 'Unknown StringLiterals style'
-          end
-        end
-
         def autocorrect(node)
           @corrections << lambda do |corrector|
             replacement = node.loc.begin.is?('"') ? "'" : '"'

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

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-# rubocop:disable SymbolName
-
 module Rubocop
   module Cop
     module Style

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

@@ -8,21 +8,14 @@ module Rubocop
       #
       # This check makes sense only on Ruby 2.0+.
       class SymbolArray < Cop
+        include ArraySyntax
+
         MSG = 'Use %i or %I for array of symbols.'
 
         def on_array(node)
           # %i and %I were introduced in Ruby 2.0
           unless RUBY_VERSION < '2.0.0'
-            return unless node.loc.begin && node.loc.begin.is?('[')
-
-            array_elems = node.children
-
-            # no need to check empty arrays
-            return unless array_elems && array_elems.size > 1
-
-            symbol_array = array_elems.all? { |e| e.type == :sym }
-
-            convention(node, :expression) if symbol_array
+            add_offence(node, :expression) if array_of?(:sym, node)
           end
         end
       end

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

@@ -12,11 +12,11 @@ module Rubocop
             match = line.match(/^( *)\t/)
             if match
               spaces = match.captures[0]
-              convention(nil,
-                         source_range(processed_source.buffer,
-                                      processed_source[0...index],
-                                      spaces.length, 1),
-                         MSG)
+              add_offence(nil,
+                          source_range(processed_source.buffer,
+                                       processed_source[0...index],
+                                       spaces.length, 1),
+                          MSG)
             end
           end
         end

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

@@ -14,7 +14,7 @@ module Rubocop
           # discard non-ternary ops
           return unless loc.respond_to?(:question)
 
-          convention(node, :expression) if loc.line != loc.colon.line
+          add_offence(node, :expression) if loc.line != loc.colon.line
         end
       end
 
@@ -31,7 +31,7 @@ module Rubocop
 
           node.children.each do |child|
             on_node(:if, child) do |c|
-              convention(c, :expression) if c.loc.respond_to?(:question)
+              add_offence(c, :expression) if c.loc.respond_to?(:question)
             end
           end
         end

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

@@ -24,7 +24,7 @@ module Rubocop
             range = source_range(processed_source.buffer,
                                  processed_source[0...-blank_lines],
                                  0, range_size)
-            convention(range, range, format(MSG, blank_lines))
+            add_offence(range, range, format(MSG, blank_lines))
           end
         end
 

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

@@ -14,7 +14,7 @@ module Rubocop
                                    processed_source[0...index],
                                    line.rstrip.length,
                                    line.length - line.rstrip.length)
-              convention(range, range)
+              add_offence(range, range)
             end
           end
         end

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

@@ -6,19 +6,9 @@ module Rubocop
       # This cop looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
       class TrivialAccessors < Cop
-        MSG = 'Use attr_%s to define trivial %s methods.'
-
-        def on_def(node)
-          method_name, args, body = *node
-
-          check(node, method_name, args, body)
-        end
+        include CheckMethods
 
-        def on_defs(node)
-          _scope, method_name, args, body = *node
-
-          check(node, method_name, args, body)
-        end
+        MSG = 'Use attr_%s to define trivial %s methods.'
 
         private
 
@@ -29,8 +19,8 @@ module Rubocop
                    'writer'
                  end
           if kind
-            convention(node, :keyword,
-                       sprintf(MSG, kind, kind))
+            add_offence(node, :keyword,
+                        sprintf(MSG, kind, kind))
           end
         end