rubbycop 0.49.0

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for uses of the case equality operator(===).
+      class CaseEquality < Cop
+        MSG = 'Avoid the use of the case equality operator `===`.'.freeze
+
+        def_node_matcher :case_equality?, '(send _ :=== _)'
+
+        def on_send(node)
+          case_equality?(node) { add_offense(node, :selector) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks for uses of the character literal ?x.
+      class CharacterLiteral < Cop
+        include StringHelp
+
+        MSG = 'Do not use the character literal - ' \
+              'use string literal instead.'.freeze
+
+        def offense?(node)
+          # we don't register an offense for things like ?\C-\M-d
+          node.loc.begin.is?('?') &&
+            node.source.size.between?(2, 3)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            string = node.source[1..-1]
+
+            # special character like \n
+            # or ' which needs to use "" or be escaped.
+            if string.length == 2 || string == "'"
+              corrector.replace(node.source_range, %("#{string}"))
+            elsif string.length == 1 # normal character
+              corrector.replace(node.source_range, "'#{string}'")
+            end
+          end
+        end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def opposite_style_detected; end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def correct_style_detected; end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cops checks for class and module names with
+      # an underscore in them.
+      class ClassAndModuleCamelCase < Cop
+        MSG = 'Use CamelCase for classes and modules.'.freeze
+
+        def on_class(node)
+          check_name(node)
+        end
+
+        def on_module(node)
+          check_name(node)
+        end
+
+        private
+
+        def check_name(node)
+          name = node.loc.name.source
+
+          add_offense(node, :name) if name =~ /_/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.'.freeze
+        COMPACT_MSG = 'Use compact module/class definition instead of ' \
+                      'nested style.'.freeze
+
+        def on_class(node)
+          _name, superclass, body = *node
+          return if superclass && style != :nested
+          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?(body) && !compact_node_name?(node)
+          add_offense(node, :name, COMPACT_MSG)
+        end
+
+        def one_child?(body)
+          body && %i[module class].include?(body.type)
+        end
+
+        def compact_node_name?(node)
+          node.loc.name.source =~ /::/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
+      class ClassCheck < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `Object#%s` over `Object#%s`.'.freeze
+
+        def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
+
+        def on_send(node)
+          class_check?(node) do |method_name|
+            return if style == method_name
+
+            add_offense(node, :selector)
+          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?'
+
+            corrector.replace(node.loc.selector, replacement)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.%s` instead of `%s.%s`.'.freeze
+
+        def on_class(node)
+          name, _superclass, body = *node
+          check(name, body)
+        end
+
+        def on_module(node)
+          name, body = *node
+          check(name, body)
+        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
+
+          _, class_name = *definee
+          add_offense(definee, :name, message(class_name, method_name))
+        end
+
+        def message(class_name, method_name)
+          format(MSG, method_name, class_name, method_name)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.name, 'self') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    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.
+      class ClassVars < Cop
+        MSG = 'Replace class var %s with a class instance var.'.freeze
+
+        def on_cvasgn(node)
+          add_offense(node, :name)
+        end
+
+        def message(node)
+          class_var, = *node
+          format(MSG, class_var)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.
+      class CollectionMethods < Cop
+        include MethodPreference
+
+        MSG = 'Prefer `%s` over `%s`.'.freeze
+
+        def on_block(node)
+          method, _args, _body = *node
+
+          check_method_node(method)
+        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, preferred_method(node.method_name), node.method_name)
+        end
+
+        def check_method_node(node)
+          return unless preferred_methods[node.method_name]
+
+          add_offense(node, :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for methods invoked via the :: operator instead
+      # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
+      class ColonMethodCall < Cop
+        MSG = 'Do not use `::` for method calls.'.freeze
+
+        def_node_matcher :java_type_node?, <<-PATTERN
+          (send
+            (const nil :Java)
+            {:boolean :byte :char :double :float :int :long :short})
+        PATTERN
+
+        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, :dot)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.loc.dot, '.') }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop enforces using `` or %x around command literals.
+      #
+      # @example
+      #   # Good if EnforcedStyle is backticks or mixed, bad if percent_x.
+      #   folders = `find . -type d`.split
+      #
+      #   # Good if EnforcedStyle is percent_x, bad if backticks or mixed.
+      #   folders = %x(find . -type d).split
+      #
+      #   # Good if EnforcedStyle is backticks, bad if percent_x or mixed.
+      #   `
+      #     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.
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # Bad unless AllowInnerBackticks is true.
+      #   `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
+
+        def on_xstr(node)
+          return if heredoc_literal?(node)
+
+          if backtick_literal?(node)
+            check_backtick_literal(node)
+          else
+            check_percent_x_literal(node)
+          end
+        end
+
+        private
+
+        def check_backtick_literal(node)
+          return if allowed_backtick_literal?(node)
+
+          add_offense(node, :expression, MSG_USE_PERCENT_X)
+        end
+
+        def check_percent_x_literal(node)
+          return if allowed_percent_x_literal?(node)
+
+          add_offense(node, :expression, MSG_USE_BACKTICKS)
+        end
+
+        def allowed_backtick_literal?(node)
+          style == :backticks && !contains_disallowed_backtick?(node) ||
+            style == :mixed && node.single_line? &&
+              !contains_disallowed_backtick?(node)
+        end
+
+        def allowed_percent_x_literal?(node)
+          style == :backticks && contains_disallowed_backtick?(node) ||
+            style == :percent_x ||
+            style == :mixed && node.multiline? ||
+            style == :mixed && contains_disallowed_backtick?(node)
+        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 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(//)
+        end
+
+        def autocorrect(node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiters).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, replacement.first)
+            corrector.replace(node.loc.end, replacement.last)
+          end
+        end
+      end
+    end
+  end
+end