rubocop 0.18.1 → 0.19.0

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

@@ -24,9 +24,9 @@ module Rubocop
           op_type = node.type.to_s
 
           if op == op_type
-            add_offence(node,
+            add_offense(node,
                         :operator,
-                        sprintf(MSG, OPS[op], op))
+                        format(MSG, OPS[op], op))
           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|
-            add_offence(comment, :expression) unless comment.text.ascii_only?
+            add_offense(comment, :expression) unless comment.text.ascii_only?
           end
         end
       end

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

@@ -10,7 +10,7 @@ module Rubocop
         def investigate(processed_source)
           processed_source.tokens.each do |t|
             if t.type == :tIDENTIFIER && !t.text.ascii_only?
-              add_offence(nil, t.pos)
+              add_offense(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)
-          add_offence(node, :selector) if command?(:attr, node)
+          add_offense(node, :selector) if command?(:attr, node)
         end
 
         def autocorrect(node)

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)
-          add_offence(node, :keyword)
+          add_offense(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')
-              add_offence(comment, :expression)
+              add_offense(comment, :expression)
             end
           end
         end

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

@@ -29,7 +29,7 @@ module Rubocop
               current_level += 1
             end
             if current_level == max + 1
-              add_offence(node, :expression, message(max)) do
+              add_offense(node, :expression, message(max)) do
                 self.max = current_level
               end
               return

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

@@ -29,9 +29,9 @@ module Rubocop
           block_begin = node.loc.begin.source
 
           if block_length > 0 && block_begin == '{'
-            add_offence(node, :begin, MULTI_LINE_MSG)
+            add_offense(node, :begin, MULTI_LINE_MSG)
           elsif block_length == 0 && block_begin != '{'
-            add_offence(node, :begin, SINGLE_LINE_MSG)
+            add_offense(node, :begin, SINGLE_LINE_MSG)
           end
         end
 

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

@@ -28,7 +28,7 @@ module Rubocop
             if !braces?(arg) || all_hashes?(args)
               correct_style_detected
             else
-              add_offence(arg, :expression,
+              add_offense(arg, :expression,
                           'Redundant curly braces around a hash parameter.') do
                 opposite_style_detected
               end
@@ -36,7 +36,7 @@ module Rubocop
           elsif braces?(arg)
             correct_style_detected
           else
-            add_offence(arg, :expression,
+            add_offense(arg, :expression,
                         'Missing curly braces around a hash parameter.') do
               opposite_style_detected
             end

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

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

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

@@ -6,7 +6,7 @@ module Rubocop
       # 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*.
+      # It will register a separate offense for each misaligned *when*.
       class CaseIndentation < Cop
         include ConfigurableEnforcedStyle
 
@@ -36,7 +36,7 @@ module Rubocop
                                    else
                                      "as deep as #{base}."
                                    end
-            add_offence(when_node, pos, msg) do
+            add_offense(when_node, pos, msg) do
               if pos.column == base_column(case_node, alternative_style)
                 opposite_style_detected
               else

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

@@ -9,8 +9,8 @@ module Rubocop
 
         MSG = 'Do not use the character literal - use string literal instead.'
 
-        def offence?(node)
-          # we don't register an offence for things like ?\C-\M-d
+        def offense?(node)
+          # we don't register an offense for things like ?\C-\M-d
           node.loc.begin.is?('?') &&
             node.loc.expression.source.size.between?(2, 3)
         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
 
-          add_offence(node, :name) if name =~ /_/
+          add_offense(node, :name) if name =~ /_/
         end
       end
     end

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

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks the style of children definitions at classes and
+      # modules. Basically there are two different styles:
+      #
+      # nested - have each child on its own line
+      #   class Foo
+      #     class Bar
+      #     end
+      #   end
+      #
+      # compact - combine definitions as much as possible
+      #   class Foo::Bar
+      #   end
+      #
+      # The compact style is only forced, for classes / modules with one child.
+      class ClassAndModuleChildren < Cop
+        include ConfigurableEnforcedStyle
+
+        NESTED_MSG = 'Use nested module/class definitions instead of ' \
+                     'compact style.'
+
+        COMPACT_MSG = 'Use compact module/class definition instead of ' \
+                      'nested style.'
+
+        def on_class(node)
+          _name, _superclass, body = *node
+          check_style(node, body)
+        end
+
+        def on_module(node)
+          _name, body = *node
+          check_style(node, body)
+        end
+
+        private
+
+        def check_style(node, body)
+          if style == :nested
+            check_nested_style(node)
+          else
+            check_compact_style(node, body)
+          end
+        end
+
+        def check_nested_style(node)
+          return unless compact_node_name?(node)
+          add_offense(node, :name, NESTED_MSG)
+        end
+
+        def check_compact_style(node, body)
+          return unless one_child?(node, body) && !compact_node_name?(node)
+          add_offense(node, :name, COMPACT_MSG)
+        end
+
+        def one_child?(node, body)
+          body && body.type != :begin
+        end
+
+        def compact_node_name?(node)
+          node.loc.name.source =~ /::/
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -3,14 +3,14 @@
 module Rubocop
   module Cop
     module Style
-      # This cop checks for uses of class variables. Offences
+      # This cop checks for uses of class variables. Offenses
       # are signaled only on assignment to class variables to
-      # reduced the number of offences that would be reported.
+      # reduced the number of offenses that would be reported.
       class ClassVars < Cop
         MSG = 'Replace class var %s with a class instance var.'
 
         def on_cvasgn(node)
-          add_offence(node, :name)
+          add_offense(node, :name)
         end
 
         def message(node)

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

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

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)
 
-          add_offence(node, :dot)
+          add_offense(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)
-              add_offence(nil, range)
+              add_offense(nil, range)
             end
           end
         end

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

@@ -20,7 +20,7 @@ module Rubocop
           # 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
+            add_offense(node, :name) if const_name !~ SNAKE_CASE
           end
         end
       end

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

@@ -29,8 +29,8 @@ module Rubocop
 
           max = cop_config['Max']
           if complexity > max
-            add_offence(node, :keyword,
-                        sprintf(MSG, method_name, complexity, max)) do
+            add_offense(node, :keyword,
+                        format(MSG, method_name, complexity, max)) do
               self.max = complexity
             end
           end

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

@@ -10,7 +10,7 @@ module Rubocop
         include CheckMethods
 
         MSG = "Omit the parentheses in defs when the method doesn't accept " \
-            'any arguments.'
+              'any arguments.'
 
         def check(node, _method_name, args, _body)
           start_line = node.loc.keyword.line
@@ -18,7 +18,7 @@ module Rubocop
 
           return if start_line == end_line
 
-          add_offence(args, :begin) if args.children == [] && args.loc.begin
+          add_offense(args, :begin) if args.children == [] && args.loc.begin
         end
 
         def autocorrect(node)

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

@@ -38,7 +38,7 @@ module Rubocop
             next if node.type == :class && !body
             next if namespace?(body)
             next if associated_comment?(node, ast_with_comments)
-            add_offence(node, :keyword, format(MSG, node.type.to_s))
+            add_offense(node, :keyword, format(MSG, node.type.to_s))
           end
         end
 

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

@@ -13,7 +13,7 @@ module Rubocop
           if proper_dot_position?(node)
             correct_style_detected
           else
-            add_offence(node, :dot) { opposite_style_detected }
+            add_offense(node, :dot) { opposite_style_detected }
           end
         end
 
@@ -29,12 +29,10 @@ module Rubocop
             end
         end
 
-        def parameter_name
-          'Style'
-        end
-
         def proper_dot_position?(node)
-          dot_line = node.loc.dot.line
+          receiver, _method_name, *_args = *node
+
+          receiver_line = receiver.loc.expression.end.line
 
           if node.loc.selector
             selector_line = node.loc.selector.line
@@ -43,15 +41,16 @@ module Rubocop
             selector_line = node.loc.begin.line
           end
 
+          # receiver and selector are on the same line
+          return true if selector_line == receiver_line
+
+          dot_line = node.loc.dot.line
+
           case style
           when :leading then dot_line == selector_line
-          when :trailing then dot_line != selector_line || same_line?(node)
+          when :trailing then dot_line != selector_line
           end
         end
-
-        def same_line?(node)
-          node.loc.dot.line == node.loc.line
-        end
       end
     end
   end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of double negation (!!) to convert something
+      # to a boolean value. As this is both cryptic and usually redundant it
+      # should be avoided.
+      #
+      # @example
+      #
+      #   # bad
+      #   !!something
+      #
+      #   # good
+      #   !something.nil?
+      class DoubleNegation < Cop
+        MSG = 'Avoid the use of double negation (!!).'
+
+        def on_send(node)
+          return unless not_node?(node)
+
+          receiver, _method_name, *_args = *node
+
+          add_offense(node, :selector) if not_node?(receiver)
+        end
+
+        private
+
+        def not_node?(node)
+          _receiver, method_name, *args = *node
+
+          # ! does not take any arguments
+          args.empty? && method_name == :! &&
+            node.loc.selector.is?('!')
+        end
+      end
+    end
+  end
+end

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

@@ -12,7 +12,7 @@ module Rubocop
           if @prev_def_end && (def_start(node) - @prev_def_end) == 1
             unless @prev_was_single_line && singe_line_def?(node) &&
                 cop_config['AllowAdjacentOneLineDefs']
-              add_offence(node, :keyword)
+              add_offense(node, :keyword)
             end
           end
 
@@ -33,6 +33,13 @@ module Rubocop
         def def_end(node)
           node.loc.end.line
         end
+
+        def autocorrect(node)
+          range = range_with_surrounding_space(node.loc.expression, :left)
+          @corrections << lambda do |corrector|
+            corrector.insert_before(range, "\n")
+          end
+        end
       end
     end
   end