rubocop 0.75.1

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of the class/module name instead of
+      # self, when defining class/module methods.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     def SomeClass.class_method
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     def self.class_method
+      #       # ...
+      #     end
+      #   end
+      class ClassMethods < Cop
+        MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'
+
+        def on_class(node)
+          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 autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.name, 'self') }
+        end
+
+        private
+
+        def check_defs(name, node)
+          # check if the class/module name matches the definee for the defs node
+          return unless name == node.receiver
+
+          add_offense(node.receiver, location: :name)
+        end
+
+        def message(node)
+          _, class_name = *node
+
+          format(MSG, method: node.parent.method_name, class: class_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of class variables. Offenses
+      # are signaled only on assignment to class variables to
+      # 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
+      #
+      #   # good
+      #   class A
+      #     @test = 10
+      #   end
+      #
+      #   class A
+      #     def test
+      #       @@test # you can access class variable without offense
+      #     end
+      #   end
+      #
+      class ClassVars < Cop
+        MSG = 'Replace class var %<class_var>s with a class ' \
+              'instance var.'
+
+        def on_cvasgn(node)
+          add_offense(node, location: :name)
+        end
+
+        def message(node)
+          class_var, = *node
+          format(MSG, class_var: class_var)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of consistent method names
+      # from the Enumerable module.
+      #
+      # 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
+      #
+      #   # good
+      #   items.map
+      #   items.map!
+      #   items.reduce
+      #   items.find
+      #   items.select
+      #
+      class CollectionMethods < Cop
+        include MethodPreference
+
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+
+        def on_block(node)
+          check_method_node(node.send_node)
+        end
+
+        def on_send(node)
+          return unless node.arguments.one? &&
+                        node.first_argument.block_pass_type?
+
+          check_method_node(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source))
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG,
+                 prefer: preferred_method(node.method_name),
+                 current: node.method_name)
+        end
+
+        def check_method_node(node)
+          return unless preferred_methods[node.method_name]
+
+          add_offense(node, location: :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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.'
+
+        def_node_matcher :java_type_node?, <<~PATTERN
+          (send
+            (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)
+
+          return unless node.receiver && node.double_colon?
+          return if node.camel_case_method?
+
+          add_offense(node, location: :dot)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.dot, '.') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces using `` or %x around command literals.
+      #
+      # @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
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @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.'
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'
+
+        def on_xstr(node)
+          return if node.heredoc?
+
+          if backtick_literal?(node)
+            check_backtick_literal(node)
+          else
+            check_percent_x_literal(node)
+          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)
+          return if allowed_backtick_literal?(node)
+
+          add_offense(node)
+        end
+
+        def check_percent_x_literal(node)
+          return if allowed_percent_x_literal?(node)
+
+          add_offense(node)
+        end
+
+        def message(node)
+          backtick_literal?(node) ? MSG_USE_PERCENT_X : MSG_USE_BACKTICKS
+        end
+
+        def allowed_backtick_literal?(node)
+          case style
+          when :backticks
+            !contains_disallowed_backtick?(node)
+          when :mixed
+            node.single_line? && !contains_disallowed_backtick?(node)
+          end
+        end
+
+        def allowed_percent_x_literal?(node)
+          case style
+          when :backticks
+            contains_disallowed_backtick?(node)
+          when :mixed
+            node.multiline? || contains_disallowed_backtick?(node)
+          when :percent_x
+            true
+          end
+        end
+
+        def contains_disallowed_backtick?(node)
+          !allow_inner_backticks? && contains_backtick?(node)
+        end
+
+        def allow_inner_backticks?
+          cop_config['AllowInnerBackticks']
+        end
+
+        def contains_backtick?(node)
+          node_body(node) =~ /`/
+        end
+
+        def node_body(node)
+          loc = node.loc
+          loc.expression.source[loc.begin.length...-loc.end.length]
+        end
+
+        def backtick_literal?(node)
+          node.loc.begin.source == '`'
+        end
+
+        def preferred_delimiter
+          (command_delimiter || default_delimiter).split(//)
+        end
+
+        def command_delimiter
+          preferred_delimiters_config['%x']
+        end
+
+        def default_delimiter
+          preferred_delimiters_config['default']
+        end
+
+        def preferred_delimiters_config
+          config.for_cop('Style/PercentLiteralDelimiters') \
+            ['PreferredDelimiters']
+        end
+      end
+    end
+  end
+end