rubocop 0.15.0 → 0.16.0

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

@@ -22,7 +22,7 @@ module Rubocop
           receiver, method_name, *_args = *node
 
           if receiver.nil? && BLACKLIST.include?(method_name)
-            convention(node, :selector)
+            add_offence(node, :selector)
           end
         end
       end

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

@@ -7,6 +7,8 @@ module Rubocop
       # Modifiers should be indented as deeps are method definitions and
       # surrounded by blank lines.
       class AccessModifierIndentation < Cop
+        include ConfigurableEnforcedStyle
+
         MSG = '%s access modifiers like %s.'
 
         PRIVATE_NODE = s(:send, nil, :private)
@@ -27,24 +29,39 @@ module Rubocop
             # except other class/module nodes
             class_node.children.compact.each do |node|
               on_node(:send, node, [:class, :module, :sclass]) do |send_node|
-                if modifier_node?(send_node)
-                  send_start_col = send_node.loc.expression.column
-
-                  if send_start_col != class_start_col + expected_indent_offset
-                    convention(send_node, :expression)
-                  end
+                if self.class.modifier_node?(send_node)
+                  check(send_node, class_start_col)
                 end
               end
             end
           end
         end
 
+        def self.modifier_node?(node)
+          [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
+        end
+
         private
 
+        def check(send_node, class_start_col)
+          access_modifier_start_col = send_node.loc.expression.column
+          offset = access_modifier_start_col - class_start_col
+
+          if offset == expected_indent_offset
+            correct_style_detected
+          else
+            add_offence(send_node, :expression) do
+              if offset == unexpected_indent_offset
+                opposite_style_detected
+              else
+                unrecognized_style_detected
+              end
+            end
+          end
+        end
+
         def message(node)
-          format(MSG,
-                 cop_config['EnforcedStyle'].capitalize,
-                 node.loc.selector.source)
+          format(MSG, style.capitalize, node.loc.selector.source)
         end
 
         def class_constructor?(block_node)
@@ -55,15 +72,13 @@ module Rubocop
         end
 
         def expected_indent_offset
-          case cop_config['EnforcedStyle'].downcase
-          when 'outdent' then 0
-          when 'indent' then 2
-          else fail 'Unknown EnforcedStyle specified'
-          end
+          style == :outdent ? 0 : IndentationWidth::CORRECT_INDENTATION
         end
 
-        def modifier_node?(node)
-          [PRIVATE_NODE, PROTECTED_NODE, PUBLIC_NODE].include?(node)
+        # An offset that is not expected, but correct if the configuration is
+        # changed.
+        def unexpected_indent_offset
+          IndentationWidth::CORRECT_INDENTATION - expected_indent_offset
         end
       end
     end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop makes sure that accessor methods are named properly.
+      #
+      # @example
+      #   # bad
+      #   def set_attribute(value) ...
+      #
+      #   # good
+      #   def attribute=(value)
+      #
+      #   # bad
+      #   def get_attribute ...
+      #
+      #   # good
+      #   def attribute ...
+      class AccessorMethodName < Cop
+        def on_def(node)
+          method_name, args, _body = *node
+          check(node, method_name.to_s, args)
+        end
+
+        def on_defs(node)
+          _scope, method_name, args, _body = *node
+          check(node, method_name.to_s, args)
+        end
+
+        private
+
+        def check(node, method_name, args)
+          if bad_reader_name?(method_name, args)
+            add_offence(node, :name,
+                        'Do not prefix reader method names with get_.')
+          elsif bad_writer_name?(method_name, args)
+            add_offence(node, :name,
+                        'Do not prefix writer method names with set_.')
+          end
+        end
+
+        def bad_reader_name?(method_name, args)
+          method_name.start_with?('get_') && args.to_a.empty?
+        end
+
+        def bad_writer_name?(method_name, args)
+          method_name.start_with?('set_') && args.to_a.one?
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,6 @@ module Rubocop
 
         def on_block(node)
           method, _args, body = *node
-
           _receiver, method_name = *method
 
           # using alias is the only option in certain scenarios
@@ -28,7 +27,20 @@ module Rubocop
 
           return if new.type == :gvar && old.type == :gvar
 
-          convention(node, :keyword)
+          add_offence(node, :keyword)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            # replace alias with alias_method
+            corrector.replace(node.loc.keyword, 'alias_method')
+            # insert a comma
+            new, old = *node
+            corrector.insert_after(new.loc.expression, ',')
+            # convert bareword arguments to symbols
+            corrector.replace(new.loc.expression, ":#{new.children.first}")
+            corrector.replace(old.loc.expression, ":#{old.children.first}")
+          end
         end
       end
     end

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

@@ -46,6 +46,14 @@ module Rubocop
 
           private
 
+          def separator_delta(first_pair, current_separator, key_delta)
+            if current_separator.is?(':')
+              0 # Colon follows directly after key
+            else
+              hash_rocket_delta(first_pair, current_separator) - key_delta
+            end
+          end
+
           def any_pairs_on_the_same_line?(node)
             lines_of_the_children = node.children.map do |pair|
               key, _value = *pair
@@ -87,13 +95,9 @@ module Rubocop
             first_pair.loc.column - current_pair.loc.column
           end
 
-          def separator_delta(first_pair, current_separator, key_delta)
-            if current_separator.is?(':')
-              0 # Colon follows directly after key
-            else
-              first_pair.loc.column + @max_key_width + 1 -
-                current_separator.column - key_delta
-            end
+          def hash_rocket_delta(first_pair, current_separator)
+            first_pair.loc.column + @max_key_width + 1 -
+              current_separator.column
           end
 
           def value_delta(first_pair, current_pair)
@@ -126,13 +130,8 @@ module Rubocop
             key.loc.column + key.loc.expression.source.length
           end
 
-          def separator_delta(first_pair, current_separator, key_delta)
-            if current_separator.is?(':')
-              0 # Colon follows directly after key
-            else
-              first_pair.loc.operator.column - current_separator.column -
-                key_delta
-            end
+          def hash_rocket_delta(first_pair, current_separator)
+            first_pair.loc.operator.column - current_separator.column
           end
 
           def value_delta(first_pair, current_pair)
@@ -161,12 +160,12 @@ module Rubocop
 
           @column_deltas = alignment_for(first_pair)
             .deltas_for_first_pair(first_pair, node)
-          convention(first_pair, :expression) unless good_alignment?
+          add_offence(first_pair, :expression) unless good_alignment?
 
           node.children.each_cons(2) do |prev, current|
             @column_deltas = alignment_for(current).deltas(first_pair, prev,
                                                            current)
-            convention(current, :expression) unless good_alignment?
+            add_offence(current, :expression) unless good_alignment?
           end
         end
 

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

@@ -24,9 +24,9 @@ module Rubocop
           op_type = node.type.to_s
 
           if op == op_type
-            convention(node,
-                       :operator,
-                       sprintf(MSG, OPS[op], op))
+            add_offence(node,
+                        :operator,
+                        sprintf(MSG, OPS[op], op))
           end
         end
 

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Common code for ordinary arrays with [] that can be written with %
+      # syntax.
+      module ArraySyntax
+        def array_of?(element_type, node)
+          return false unless node.loc.begin && node.loc.begin.is?('[')
+
+          array_elems = node.children
+
+          # no need to check empty arrays
+          return false unless array_elems && array_elems.size > 1
+
+          array_elems.all? { |e| e.type == element_type }
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Rubocop
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            convention(comment, :expression) unless comment.text.ascii_only?
+            add_offence(comment, :expression) unless comment.text.ascii_only?
           end
         end
       end

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

@@ -1,7 +1,5 @@
 # encoding: utf-8
 
-# rubocop:disable SymbolName
-
 module Rubocop
   module Cop
     module Style
@@ -12,7 +10,7 @@ module Rubocop
         def investigate(processed_source)
           processed_source.tokens.each do |t|
             if t.type == :tIDENTIFIER && !t.text.ascii_only?
-              convention(nil, t.pos)
+              add_offence(nil, t.pos)
             end
           end
         end

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

@@ -8,7 +8,7 @@ module Rubocop
         MSG = 'Do not use `attr`. Use `attr_reader` instead.'
 
         def on_send(node)
-          convention(node, :selector) if command?(:attr, node)
+          add_offence(node, :selector) if command?(:attr, node)
         end
 
         def autocorrect(node)

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

@@ -11,7 +11,7 @@ module Rubocop
           items.each_cons(2) do |prev, current|
             if current.loc.line > prev.loc.line && start_of_line?(current.loc)
               @column_delta = items.first.loc.column - current.loc.column
-              convention(current, :expression) if @column_delta != 0
+              add_offence(current, :expression) if @column_delta != 0
             end
           end
         end
@@ -30,17 +30,7 @@ module Rubocop
           @corrections << lambda do |corrector|
             expr = node.loc.expression
             each_line(expr) do |line_begin_pos, line|
-              starts_with_space =
-                expr.source_buffer.source[line_begin_pos] =~ / /
-              pos_to_remove = if column_delta > 0 || starts_with_space
-                                line_begin_pos
-                              else
-                                line_begin_pos - column_delta.abs
-                              end
-              range = Parser::Source::Range.new(expr.source_buffer,
-                                                pos_to_remove,
-                                                pos_to_remove +
-                                                column_delta.abs)
+              range = calculate_range(expr, line_begin_pos, column_delta)
               if column_delta > 0
                 corrector.insert_before(range, ' ' * column_delta)
               else
@@ -50,6 +40,17 @@ module Rubocop
           end
         end
 
+        def calculate_range(expr, line_begin_pos, column_delta)
+          starts_with_space = expr.source_buffer.source[line_begin_pos] =~ / /
+          pos_to_remove = if column_delta > 0 || starts_with_space
+                            line_begin_pos
+                          else
+                            line_begin_pos - column_delta.abs
+                          end
+          Parser::Source::Range.new(expr.source_buffer, pos_to_remove,
+                                    pos_to_remove + column_delta.abs)
+        end
+
         def remove(range, corrector)
           original_stderr = $stderr
           $stderr = StringIO.new # Avoid error messages on console

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

@@ -8,7 +8,7 @@ module Rubocop
         MSG = 'Avoid the use of BEGIN blocks.'
 
         def on_preexe(node)
-          convention(node, :keyword)
+          add_offence(node, :keyword)
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Rubocop
         def investigate(processed_source)
           processed_source.comments.each do |comment|
             if comment.text.start_with?('=begin')
-              convention(comment, :expression)
+              add_offence(comment, :expression)
             end
           end
         end

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

@@ -9,6 +9,8 @@ module Rubocop
       #
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Cop
+        include ConfigurableMax
+
         NESTING_BLOCKS = [:case, :if, :while, :while_post, :until, :until_post,
                           :for, :resbody]
 
@@ -27,7 +29,9 @@ module Rubocop
               current_level += 1
             end
             if current_level == max + 1
-              convention(node, :expression, message(max))
+              add_offence(node, :expression, message(max)) do
+                self.max = current_level
+              end
               return
             end
           end

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

@@ -13,7 +13,7 @@ module Rubocop
           _receiver, method_name, *args = *node
           if args.any?
             block = get_block(args.last)
-            if block && !has_parentheses?(node) && !operator?(method_name)
+            if block && !parentheses?(node) && !operator?(method_name)
               # If there are no parentheses around the arguments, then braces
               # and do-end have different meaning due to how they bind, so we
               # allow either.
@@ -29,9 +29,9 @@ module Rubocop
           block_begin = node.loc.begin.source
 
           if block_length > 0 && block_begin == '{'
-            convention(node, :begin, MULTI_LINE_MSG)
+            add_offence(node, :begin, MULTI_LINE_MSG)
           elsif block_length == 0 && block_begin != '{'
-            convention(node, :begin, SINGLE_LINE_MSG)
+            add_offence(node, :begin, SINGLE_LINE_MSG)
           end
         end
 
@@ -65,7 +65,7 @@ module Rubocop
           end
         end
 
-        def has_parentheses?(send_node)
+        def parentheses?(send_node)
           send_node.loc.begin
         end
 

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

@@ -5,41 +5,67 @@ module Rubocop
     module Style
       # This cop checks for braces in method calls with hash parameters.
       class BracesAroundHashParameters < Cop
+        include ConfigurableEnforcedStyle
+
         def on_send(node)
           _receiver, method_name, *args = *node
 
-          # discard attr writer methods.
+          # Discard attr writer methods.
           return if method_name.to_s.end_with?('=')
-          # discard operator methods
+          # Discard operator methods.
           return if OPERATOR_METHODS.include?(method_name)
 
-          # we care only for the first argument
+          # We care only for the last argument.
           arg = args.last
-          return unless arg && arg.type == :hash && arg.children.any?
-
-          has_braces = !arg.loc.begin.nil?
-          all_hashes = args.length > 1 && args.all? { |a| a.type == :hash }
-
-          if style == :no_braces && has_braces && !all_hashes
-            convention(arg,
-                       :expression,
-                       'Redundant curly braces around a hash parameter.')
-          elsif style == :braces && !has_braces
-            convention(arg,
-                       :expression,
-                       'Missing curly braces around a hash parameter.')
-          end
+
+          check(arg, args) if non_empty_hash?(arg)
         end
 
         private
 
-        def style
-          case cop_config['EnforcedStyle']
-          when 'braces' then :braces
-          when 'no_braces' then :no_braces
-          else fail 'Unknown style selected!'
+        def check(arg, args)
+          if style == :no_braces
+            if !braces?(arg) || all_hashes?(args)
+              correct_style_detected
+            else
+              add_offence(arg, :expression,
+                          'Redundant curly braces around a hash parameter.') do
+                opposite_style_detected
+              end
+            end
+          elsif braces?(arg)
+            correct_style_detected
+          else
+            add_offence(arg, :expression,
+                        'Missing curly braces around a hash parameter.') do
+              opposite_style_detected
+            end
+          end
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            if style == :no_braces
+              corrector.remove(node.loc.begin)
+              corrector.remove(node.loc.end)
+            elsif style == :braces
+              corrector.insert_before(node.loc.expression, '{')
+              corrector.insert_after(node.loc.expression, '}')
+            end
           end
         end
+
+        def non_empty_hash?(arg)
+          arg && arg.type == :hash && arg.children.any?
+        end
+
+        def braces?(arg)
+          !arg.loc.begin.nil?
+        end
+
+        def all_hashes?(args)
+          args.length > 1 && args.all? { |a| a.type == :hash }
+        end
       end
     end
   end