rubocop 0.15.0 → 0.16.0

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

@@ -10,7 +10,7 @@ module Rubocop
         def on_send(node)
           _receiver, method_name, *_args = *node
 
-          convention(node, :selector) if method_name == :===
+          add_offence(node, :selector) if method_name == :===
         end
       end
     end

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

@@ -3,21 +3,40 @@
 module Rubocop
   module Cop
     module Style
-      # This cop checks whether the *when*s of a *case* expression
-      # are indented as deep as its *case* keyword.
+      # This cop checks how the *when*s of a *case* expression
+      # are indented in relation to its *case* or *end* keyword.
       #
       # It will register a separate offence for each misaligned *when*.
       class CaseIndentation < Cop
-        MSG = 'Indent when as deep as case.'
-
         def on_case(case_node)
           _condition, *whens, _else = *case_node
 
-          case_column = case_node.location.keyword.column
+          base, indent = cop_config.values_at('IndentWhenRelativeTo',
+                                              'IndentOneStep')
+          base_column = base_column(case_node, base)
 
           whens.each do |when_node|
             pos = when_node.loc.keyword
-            convention(when_node, pos) if pos.column != case_column
+            expected_column = base_column +
+              (indent ? IndentationWidth::CORRECT_INDENTATION : 0)
+            if pos.column != expected_column
+              msg = 'Indent when ' + if indent
+                                       "one step more than #{base}."
+                                     else
+                                       "as deep as #{base}."
+                                     end
+              add_offence(when_node, pos, msg)
+            end
+          end
+        end
+
+        private
+
+        def base_column(case_node, base)
+          case base
+          when 'case' then case_node.location.keyword.column
+          when 'end'  then case_node.location.end.column
+          else fail "Unknown IndentWhenRelativeTo: #{base}"
           end
         end
       end

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

@@ -21,7 +21,7 @@ module Rubocop
         def check_name(node)
           name = node.loc.name.source
 
-          convention(node, :name) if name =~ /_/
+          add_offence(node, :name) if name =~ /_/
         end
       end
     end

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

@@ -7,41 +7,29 @@ module Rubocop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       class ClassLength < Cop
-        include Util
-
-        MSG = 'Class definition is too long. [%d/%d]'
+        include CodeLength
 
         def on_class(node)
           check(node)
         end
 
-        def max_length
-          cop_config['Max']
-        end
+        private
 
-        def count_comments?
-          cop_config['CountComments']
+        def message
+          'Class definition is too long. [%d/%d]'
         end
 
-        private
-
-        def check(node)
+        def code_length(node)
           class_body_line_numbers = line_range(node).to_a[1...-1]
 
           target_line_numbers = class_body_line_numbers -
                                   line_numbers_of_inner_classes(node)
 
-          class_length = target_line_numbers.reduce(0) do |length, line_number|
+          target_line_numbers.reduce(0) do |length, line_number|
             source_line = processed_source[line_number]
-            next length if source_line.blank?
-            next length if !count_comments? && comment_line?(source_line)
+            next length if irrelevant_line(source_line)
             length + 1
           end
-
-          if class_length > max_length
-            message = sprintf(MSG, class_length, max_length)
-            convention(node, :keyword, message)
-          end
         end
 
         def line_numbers_of_inner_classes(node)

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

@@ -12,7 +12,7 @@ module Rubocop
         def on_defs(node)
           definee, _name, _args, _body = *node
 
-          convention(definee, :name) if definee.type == :const
+          add_offence(definee, :name) if definee.type == :const
         end
       end
     end

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

@@ -10,7 +10,7 @@ module Rubocop
         MSG = 'Replace class var %s with a class instance var.'
 
         def on_cvasgn(node)
-          convention(node, :name)
+          add_offence(node, :name)
         end
 
         def message(node)

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Common functionality for checking length of code segments.
+      module CodeLength
+        include ConfigurableMax
+
+        def max_length
+          cop_config['Max']
+        end
+
+        def count_comments?
+          cop_config['CountComments']
+        end
+
+        def check(node, *_)
+          length = code_length(node)
+          if length > max_length
+            add_offence(node, :keyword, sprintf(message, length,
+                                                max_length)) do
+              self.max = length
+            end
+          end
+        end
+
+        # Returns true for lines that shall not be included in the count.
+        def irrelevant_line(source_line)
+          source_line.blank? || !count_comments? && comment_line?(source_line)
+        end
+      end
+    end
+  end
+end

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

@@ -45,7 +45,7 @@ module Rubocop
           _receiver, method_name, *_args = *node
 
           if preferred_methods[method_name]
-            convention(
+            add_offence(
               node, :selector,
               sprintf(MSG,
                       preferred_method(method_name),

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

@@ -15,7 +15,7 @@ module Rubocop
           return unless receiver && node.loc.dot && node.loc.dot.is?('::')
           return if allowed_name(_method_name.to_s)
 
-          convention(node, :dot)
+          add_offence(node, :dot)
         end
 
         def allowed_name(method_name)

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

@@ -21,7 +21,7 @@ module Rubocop
                 range = Parser::Source::Range.new(processed_source.buffer,
                                                   start,
                                                   start + length)
-                convention(nil, range)
+                add_offence(nil, range)
               end
             end
           end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Handles `EnforcedStyle` configuration parameters.
+      module ConfigurableEnforcedStyle
+        def opposite_style_detected
+          self.config_to_allow_offences ||=
+            { 'EnforcedStyle' => alternative_style.to_s }
+          both_styles_detected if config_to_allow_offences['Enabled']
+        end
+
+        def correct_style_detected
+          # Enabled:true indicates, later when the opposite style is detected,
+          # that the correct style is used somewhere.
+          self.config_to_allow_offences ||= { 'Enabled' => true }
+          both_styles_detected if config_to_allow_offences['EnforcedStyle']
+        end
+
+        def both_styles_detected
+          # Both correct and opposite styles exist.
+          self.config_to_allow_offences = { 'Enabled' => false }
+        end
+
+        def unrecognized_style_detected
+          # All we can do is to disable.
+          self.config_to_allow_offences = { 'Enabled' => false }
+        end
+
+        def style
+          s = cop_config['EnforcedStyle']
+          if cop_config['SupportedStyles'].include?(s)
+            s.to_sym
+          else
+            fail "Unknown style #{s} selected!"
+          end
+        end
+
+        def alternative_style
+          a = cop_config['SupportedStyles'].map(&:to_sym)
+          if a.size != 2
+            fail 'alternative_style can only be used when there are exactly ' +
+              '2 SupportedStyles'
+          end
+          style == a.first ? a.last : a.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Handles `Max` configuration parameters, especially setting them to an
+      # appropriate value with --auto-gen-config.
+      module ConfigurableMax
+        def max=(value)
+          cfg = self.config_to_allow_offences ||= {}
+          value = [cfg['Max'], value].max if cfg['Max']
+          cfg['Max'] = value
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,8 @@ module Rubocop
       # This module provides functionality for checking if names match the
       # configured EnforcedStyle.
       module ConfigurableNaming
+        include ConfigurableEnforcedStyle
+
         SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
         CAMEL_CASE = /^@?[a-z][\da-zA-Z]+[!?=]?$/
 
@@ -14,20 +16,12 @@ module Rubocop
 
           name = range.source.to_sym
           unless matches_config?(name) || Cop::OPERATOR_METHODS.include?(name)
-            convention(node, range, message(cop_config['EnforcedStyle']))
+            add_offence(node, range, message(style))
           end
         end
 
         def matches_config?(name)
-          case cop_config['EnforcedStyle']
-          when 'snake_case'
-            name =~ SNAKE_CASE
-          when 'camelCase'
-            name =~ CAMEL_CASE
-          else
-            fail 'Illegal value for EnforcedStyle. Must be snake_case or ' +
-              'camelCase.'
-          end
+          name =~ (style == :snake_case ? SNAKE_CASE : CAMEL_CASE)
         end
 
         # Returns a range containing the method name after the given regexp and

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

@@ -15,10 +15,12 @@ module Rubocop
         def on_casgn(node)
           _scope, const_name, value = *node
 
-          # We cannot know the result of method calls line
+          # We cannot know the result of method calls like
           # NewClass = something_that_returns_a_class
-          unless value && [:send, :block].include?(value.type)
-            convention(node, :name) if const_name !~ SNAKE_CASE
+          # It's also ok to assign a class constant another class constant
+          # SomeClass = SomeOtherClass
+          unless value && [:send, :block, :const].include?(value.type)
+            add_offence(node, :name) if const_name !~ SNAKE_CASE
           end
         end
       end

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

@@ -14,30 +14,25 @@ module Rubocop
       # and ||/or is shorthand for a sequence of ifs, so they also add one.
       # Loops can be said to have an exit condition, so they add one.
       class CyclomaticComplexity < Cop
+        include CheckMethods
+        include ConfigurableMax
+
         MSG = 'Cyclomatic complexity for %s is too high. [%d/%d]'
         DECISION_POINT_NODES = [:if, :while, :until, :for, :rescue, :when,
                                 :and, :or]
 
-        def on_def(node)
-          method_name, _args, _body = *node
-          check(node, method_name)
-        end
-
-        def on_defs(node)
-          _scope, method_name, _args, _body = *node
-          check(node, method_name)
-        end
-
         private
 
-        def check(node, method_name)
+        def check(node, method_name, *_)
           complexity = 1
           on_node(DECISION_POINT_NODES, node) { complexity += 1 }
 
           max = cop_config['Max']
           if complexity > max
-            convention(node, :keyword,
-                       sprintf(MSG, method_name, complexity, max))
+            add_offence(node, :keyword,
+                        sprintf(MSG, method_name, complexity, max)) do
+              self.max = complexity
+            end
           end
         end
       end

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

@@ -7,27 +7,18 @@ module Rubocop
       # that does not take any arguments. Both instance and
       # class/singleton methods are checked.
       class DefWithParentheses < Cop
+        include CheckMethods
+
         MSG = "Omit the parentheses in defs when the method doesn't accept " +
             'any arguments.'
 
-        def on_def(node)
-          start_line = node.loc.keyword.line
-          end_line = node.loc.end.line
-
-          return if start_line == end_line
-
-          _, args = *node
-          convention(args, :begin) if args.children == [] && args.loc.begin
-        end
-
-        def on_defs(node)
+        def check(node, _method_name, args, _body)
           start_line = node.loc.keyword.line
           end_line = node.loc.end.line
 
           return if start_line == end_line
 
-          _, _, args = *node
-          convention(args, :begin) if args.children == [] && args.loc.begin
+          add_offence(args, :begin) if args.children == [] && args.loc.begin
         end
 
         def autocorrect(node)
@@ -37,36 +28,6 @@ module Rubocop
           end
         end
       end
-
-      # This cop checks for missing parentheses in the definition of a
-      # method, that takes arguments. Both instance and
-      # class/singleton methods are checked.
-      class DefWithoutParentheses < Cop
-        MSG = 'Use def with parentheses when there are arguments.'
-
-        def on_def(node)
-          _, args = *node
-
-          if args.children.size > 0 && args.loc.begin.nil?
-            convention(args, :expression)
-          end
-        end
-
-        def on_defs(node)
-          _, _, args = *node
-
-          if args.children.size > 0 && args.loc.begin.nil?
-            convention(args, :expression)
-          end
-        end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            corrector.insert_before(node.loc.expression, '(')
-            corrector.insert_after(node.loc.expression, ')')
-          end
-        end
-      end
     end
   end
 end

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

@@ -36,7 +36,7 @@ module Rubocop
             next if node.type == :class && !body
             next if namespace?(body)
             next unless ast_with_comments[node].empty?
-            convention(node, :keyword, format(MSG, node.type.to_s))
+            add_offence(node, :keyword, format(MSG, node.type.to_s))
           end
         end
 

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

@@ -10,7 +10,7 @@ module Rubocop
         def on_send(node)
           return unless node.loc.dot
 
-          convention(node, :dot) unless proper_dot_position?(node)
+          add_offence(node, :dot) unless proper_dot_position?(node)
         end
 
         private
@@ -27,10 +27,14 @@ module Rubocop
 
           case cop_config['Style'].downcase
           when 'leading' then dot_line == selector_line
-          when 'trailing' then dot_line != selector_line
+          when 'trailing' then dot_line != selector_line || same_line?(node)
           else fail 'Unknown dot position style selected.'
           end
         end
+
+        def same_line?(node)
+          node.loc.dot.line == node.loc.line
+        end
       end
     end
   end