rubocop 0.51.0 → 0.87.0

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

@@ -6,38 +6,118 @@ module RuboCop
       # 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
+      # @example EnforcedStyle: nested (default)
+      #   # good
+      #   # have each child on its own line
       #   class Foo
       #     class Bar
       #     end
       #   end
       #
-      # compact - combine definitions as much as possible
+      # @example EnforcedStyle: compact
+      #   # good
+      #   # 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
+        include RangeHelp
 
         NESTED_MSG = 'Use nested module/class definitions instead of ' \
-                     'compact style.'.freeze
+                     'compact style.'
         COMPACT_MSG = 'Use compact module/class definition instead of ' \
-                      'nested style.'.freeze
+                      'nested style.'
 
         def on_class(node)
-          _name, superclass, body = *node
-          return if superclass && style != :nested
-          check_style(node, body)
+          return if node.parent_class && style != :nested
+
+          check_style(node, node.body)
         end
 
         def on_module(node)
-          _name, body = *node
-          check_style(node, body)
+          check_style(node, node.body)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            return if node.class_type? && node.parent_class && style != :nested
+
+            nest_or_compact(corrector, node)
+          end
         end
 
         private
 
+        def nest_or_compact(corrector, node)
+          if style == :nested
+            nest_definition(corrector, node)
+          else
+            compact_definition(corrector, node)
+          end
+        end
+
+        def nest_definition(corrector, node)
+          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
+          padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
+
+          replace_keyword_with_module(corrector, node)
+          split_on_double_colon(corrector, node, padding)
+          add_trailing_end(corrector, node, padding_for_trailing_end)
+        end
+
+        def replace_keyword_with_module(corrector, node)
+          corrector.replace(node.loc.keyword, 'module')
+        end
+
+        def split_on_double_colon(corrector, node, padding)
+          children_definition = node.children.first
+          range = range_between(children_definition.loc.double_colon.begin_pos,
+                                children_definition.loc.double_colon.end_pos)
+          replacement = "\n#{padding}#{node.loc.keyword.source} "
+
+          corrector.replace(range, replacement)
+        end
+
+        def add_trailing_end(corrector, node, padding)
+          replacement = "#{padding}end\n#{leading_spaces(node)}end"
+          corrector.replace(node.loc.end, replacement)
+        end
+
+        def compact_definition(corrector, node)
+          compact_node(corrector, node)
+          remove_end(corrector, node.body)
+        end
+
+        def compact_node(corrector, node)
+          replacement = "#{node.body.type} #{compact_identifier_name(node)}"
+          range = range_between(node.loc.keyword.begin_pos,
+                                node.body.loc.name.end_pos)
+          corrector.replace(range, replacement)
+        end
+
+        def compact_identifier_name(node)
+          "#{node.identifier.const_name}::" \
+            "#{node.body.children.first.const_name}"
+        end
+
+        def remove_end(corrector, body)
+          range = range_between(
+            body.loc.end.begin_pos - leading_spaces(body).size,
+            body.loc.end.end_pos + 1
+          )
+          corrector.remove(range)
+        end
+
+        def leading_spaces(node)
+          node.source_range.source_line[/\A\s*/]
+        end
+
+        def indent_width
+          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
+        end
+
         def check_style(node, body)
           if style == :nested
             check_nested_style(node)
@@ -48,11 +128,13 @@ module RuboCop
 
         def check_nested_style(node)
           return unless compact_node_name?(node)
+
           add_offense(node, location: :name, message: NESTED_MSG)
         end
 
         def check_compact_style(node, body)
           return unless one_child?(body) && !compact_node_name?(node)
+
           add_offense(node, location: :name, message: COMPACT_MSG)
         end
 
@@ -61,7 +143,7 @@ module RuboCop
         end
 
         def compact_node_name?(node)
-          node.loc.name.source =~ /::/
+          /::/.match?(node.loc.name.source)
         end
       end
     end

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

@@ -4,10 +4,29 @@ module RuboCop
   module Cop
     module Style
       # This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
+      #
+      # @example EnforcedStyle: is_a? (default)
+      #   # bad
+      #   var.kind_of?(Date)
+      #   var.kind_of?(Integer)
+      #
+      #   # good
+      #   var.is_a?(Date)
+      #   var.is_a?(Integer)
+      #
+      # @example EnforcedStyle: kind_of?
+      #   # bad
+      #   var.is_a?(Time)
+      #   var.is_a?(String)
+      #
+      #   # good
+      #   var.kind_of?(Time)
+      #   var.kind_of?(String)
+      #
       class ClassCheck < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Prefer `Object#%s` over `Object#%s`.'.freeze
+        MSG = 'Prefer `Object#%<prefer>s` over `Object#%<current>s`.'
 
         def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
 
@@ -19,14 +38,6 @@ module RuboCop
           end
         end
 
-        def message(node)
-          if node.method?(:is_a?)
-            format(MSG, 'kind_of?', 'is_a?')
-          else
-            format(MSG, 'is_a?', 'kind_of?')
-          end
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
@@ -34,6 +45,14 @@ module RuboCop
             corrector.replace(node.loc.selector, replacement)
           end
         end
+
+        def message(node)
+          if node.method?(:is_a?)
+            format(MSG, prefer: 'kind_of?', current: 'is_a?')
+          else
+            format(MSG, prefer: 'is_a?', current: 'kind_of?')
+          end
+        end
       end
     end
   end

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

@@ -10,57 +10,49 @@ module RuboCop
       #   # bad
       #   class SomeClass
       #     def SomeClass.class_method
-      #       ...
+      #       # ...
       #     end
       #   end
       #
       #   # good
       #   class SomeClass
       #     def self.class_method
-      #       ...
+      #       # ...
       #     end
       #   end
       class ClassMethods < Cop
-        MSG = 'Use `self.%s` instead of `%s.%s`.'.freeze
+        MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'
 
         def on_class(node)
-          name, _superclass, body = *node
-          check(name, body)
+          return unless node.body
+
+          if node.body.defs_type?
+            check_defs(node.identifier, node.body)
+          elsif node.body.begin_type?
+            node.body.each_child_node(:defs) do |def_node|
+              check_defs(node.identifier, def_node)
+            end
+          end
         end
+        alias on_module on_class
 
-        def on_module(node)
-          name, body = *node
-          check(name, body)
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.name, 'self') }
         end
 
         private
 
-        def check(name, node)
-          return unless node
-
-          if node.defs_type?
-            check_defs(name, node)
-          elsif node.begin_type?
-            node.each_child_node(:defs) { |n| check_defs(name, n) }
-          end
-        end
-
         def check_defs(name, node)
-          definee, method_name, _args, _body = *node
           # check if the class/module name matches the definee for the defs node
-          return unless name == definee
+          return unless name == node.receiver
 
-          _, class_name = *definee
-          add_offense(definee, location: :name,
-                               message: message(class_name, method_name))
+          add_offense(node.receiver, location: :name)
         end
 
-        def message(class_name, method_name)
-          format(MSG, method_name, class_name, method_name)
-        end
+        def message(node)
+          _, class_name = *node
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.name, 'self') }
+          format(MSG, method: node.parent.method_name, class: class_name)
         end
       end
     end

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

@@ -5,17 +5,63 @@ module RuboCop
     module Style
       # This cop checks for uses of class variables. Offenses
       # are signaled only on assignment to class variables to
-      # reduced the number of offenses that would be reported.
+      # reduce the number of offenses that would be reported.
+      #
+      # You have to be careful when setting a value for a class
+      # variable; if a class has been inherited, changing the
+      # value of a class variable also affects the inheriting
+      # classes. This means that it's almost always better to
+      # use a class instance variable instead.
+      #
+      # @example
+      #   # bad
+      #   class A
+      #     @@test = 10
+      #   end
+      #
+      #   class A
+      #     def self.test(name, value)
+      #       class_variable_set("@@#{name}", value)
+      #     end
+      #   end
+      #
+      #   class A; end
+      #   A.class_variable_set(:@@test, 10)
+      #
+      #   # good
+      #   class A
+      #     @test = 10
+      #   end
+      #
+      #   class A
+      #     def test
+      #       @@test # you can access class variable without offense
+      #     end
+      #   end
+      #
+      #   class A
+      #     def self.test(name)
+      #       class_variable_get("@@#{name}") # you can access without offense
+      #     end
+      #   end
+      #
       class ClassVars < Cop
-        MSG = 'Replace class var %s with a class instance var.'.freeze
+        MSG = 'Replace class var %<class_var>s with a class ' \
+              'instance var.'
 
         def on_cvasgn(node)
           add_offense(node, location: :name)
         end
 
+        def on_send(node)
+          return unless node.method?(:class_variable_set)
+
+          add_offense(node.first_argument)
+        end
+
         def message(node)
           class_var, = *node
-          format(MSG, class_var)
+          format(MSG, class_var: class_var)
         end
       end
     end

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

@@ -9,10 +9,38 @@ module RuboCop
       # Unfortunately we cannot actually know if a method is from
       # Enumerable or not (static analysis limitation), so this cop
       # can yield some false positives.
+      #
+      # You can customize the mapping from undesired method to desired method.
+      #
+      # e.g. to use `detect` over `find`:
+      #
+      #   Style/CollectionMethods:
+      #     PreferredMethods:
+      #       find: detect
+      #
+      # The default mapping for `PreferredMethods` behaves as follows.
+      #
+      # @example
+      #   # bad
+      #   items.collect
+      #   items.collect!
+      #   items.inject
+      #   items.detect
+      #   items.find_all
+      #   items.member?
+      #
+      #   # good
+      #   items.map
+      #   items.map!
+      #   items.reduce
+      #   items.find
+      #   items.select
+      #   items.include?
+      #
       class CollectionMethods < Cop
         include MethodPreference
 
-        MSG = 'Prefer `%s` over `%s`.'.freeze
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
         def on_block(node)
           check_method_node(node.send_node)
@@ -35,7 +63,9 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, preferred_method(node.method_name), node.method_name)
+          format(MSG,
+                 prefer: preferred_method(node.method_name),
+                 current: node.method_name)
         end
 
         def check_method_node(node)

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

@@ -5,15 +5,30 @@ module RuboCop
     module Style
       # This cop checks for methods invoked via the :: operator instead
       # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      #
+      # @example
+      #   # bad
+      #   Timeout::timeout(500) { do_something }
+      #   FileUtils::rmdir(dir)
+      #   Marshal::dump(obj)
+      #
+      #   # good
+      #   Timeout.timeout(500) { do_something }
+      #   FileUtils.rmdir(dir)
+      #   Marshal.dump(obj)
+      #
       class ColonMethodCall < Cop
-        MSG = 'Do not use `::` for method calls.'.freeze
+        MSG = 'Do not use `::` for method calls.'
 
-        def_node_matcher :java_type_node?, <<-PATTERN
+        def_node_matcher :java_type_node?, <<~PATTERN
           (send
-            (const nil? :Java)
-            {:boolean :byte :char :double :float :int :long :short})
+            (const nil? :Java) _)
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [RedundantSelf]
+        end
+
         def on_send(node)
           # ignore Java interop code like Java::int
           return if java_type_node?(node)

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for class methods that are defined using the `::`
+      # operator instead of the `.` operator.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     def self::bar
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.bar
+      #     end
+      #   end
+      #
+      class ColonMethodDefinition < Cop
+        MSG = 'Do not use `::` for defining class methods.'
+
+        def on_defs(node)
+          return unless node.loc.operator.source == '::'
+
+          add_offense(node, location: :operator)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.operator, '.') }
+        end
+      end
+    end
+  end
+end

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

@@ -5,35 +5,84 @@ module RuboCop
     module Style
       # This cop enforces using `` or %x around command literals.
       #
-      # @example
-      #   # Good if EnforcedStyle is backticks or mixed, bad if percent_x.
+      # @example EnforcedStyle: backticks (default)
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # good
       #   folders = `find . -type d`.split
       #
-      #   # Good if EnforcedStyle is percent_x, bad if backticks or mixed.
+      #   # good
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
       #   folders = %x(find . -type d).split
       #
-      #   # Good if EnforcedStyle is backticks, bad if percent_x or mixed.
+      #   # bad
       #   `
       #     ln -s foo.example.yml foo.example
       #     ln -s bar.example.yml bar.example
       #   `
       #
-      #   # Good if EnforcedStyle is percent_x or mixed, bad if backticks.
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
       #   %x(
       #     ln -s foo.example.yml foo.example
       #     ln -s bar.example.yml bar.example
       #   )
       #
-      #   # Bad unless AllowInnerBackticks is true.
+      # @example EnforcedStyle: percent_x
+      #   # bad
+      #   folders = `find . -type d`.split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = %x(find . -type d).split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example AllowInnerBackticks: false (default)
+      #   # If `false`, the cop will always recommend using `%x` if one or more
+      #   # backticks are found in the command string.
+      #
+      #   # bad
+      #   `echo \`ls\``
+      #
+      #   # good
+      #   %x(echo `ls`)
+      #
+      # @example AllowInnerBackticks: true
+      #   # good
       #   `echo \`ls\``
       class CommandLiteral < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_USE_BACKTICKS = 'Use backticks around command string.'.freeze
-        MSG_USE_PERCENT_X = 'Use `%x` around command string.'.freeze
+        MSG_USE_BACKTICKS = 'Use backticks around command string.'
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'
 
         def on_xstr(node)
-          return if heredoc_literal?(node)
+          return if node.heredoc?
 
           if backtick_literal?(node)
             check_backtick_literal(node)
@@ -42,6 +91,21 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiter).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, replacement.first)
+            corrector.replace(node.loc.end, replacement.last)
+          end
+        end
+
         private
 
         def check_backtick_literal(node)
@@ -89,7 +153,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          node_body(node) =~ /`/
+          /`/.match?(node_body(node))
         end
 
         def node_body(node)
@@ -97,32 +161,25 @@ module RuboCop
           loc.expression.source[loc.begin.length...-loc.end.length]
         end
 
-        def heredoc_literal?(node)
-          node.loc.respond_to?(:heredoc_body)
-        end
-
         def backtick_literal?(node)
           node.loc.begin.source == '`'
         end
 
-        def preferred_delimiters
-          config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']['%x'].split(//)
+        def preferred_delimiter
+          (command_delimiter || default_delimiter).split(//)
         end
 
-        def autocorrect(node)
-          return if contains_backtick?(node)
+        def command_delimiter
+          preferred_delimiters_config['%x']
+        end
 
-          replacement = if backtick_literal?(node)
-                          ['%x', ''].zip(preferred_delimiters).map(&:join)
-                        else
-                          %w[` `]
-                        end
+        def default_delimiter
+          preferred_delimiters_config['default']
+        end
 
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
-          end
+        def preferred_delimiters_config
+          config.for_cop('Style/PercentLiteralDelimiters') \
+            ['PreferredDelimiters']
         end
       end
     end