rubocop 0.87.1

data/lib/rubocop/cop/mixin/unused_argument.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Common functionality for cops handling unused arguments.
+      module UnusedArgument
+        extend NodePattern::Macros
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        private
+
+        def check_argument(variable)
+          return if variable.should_be_unused?
+          return if variable.referenced?
+
+          message = message(variable)
+          add_offense(variable.declaration_node, location: :name,
+                                                 message: message)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining node visibility.
+    module VisibilityHelp
+      extend NodePattern::Macros
+
+      VISIBILITY_SCOPES = %i[private protected public].freeze
+
+      private
+
+      def node_visibility(node)
+        scope = find_visibility_start(node)
+        scope&.method_name || :public
+      end
+
+      def find_visibility_start(node)
+        left_siblings_of(node)
+          .reverse
+          .find(&method(:visibility_block?))
+      end
+
+      # Navigate to find the last protected method
+      def find_visibility_end(node)
+        possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
+        right = right_siblings_of(node)
+        right.find do |child_node|
+          possible_visibilities.include?(node_visibility(child_node))
+        end || right.last
+      end
+
+      def left_siblings_of(node)
+        siblings_of(node)[0, node.sibling_index]
+      end
+
+      def right_siblings_of(node)
+        siblings_of(node)[node.sibling_index..-1]
+      end
+
+      def siblings_of(node)
+        node.parent.children
+      end
+
+      def_node_matcher :visibility_block?, <<~PATTERN
+        (send nil? { :private :protected :public })
+      PATTERN
+    end
+  end
+end

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that accessor methods are named properly.
+      #
+      # @example
+      #   # bad
+      #   def set_attribute(value)
+      #   end
+      #
+      #   # good
+      #   def attribute=(value)
+      #   end
+      #
+      #   # bad
+      #   def get_attribute
+      #   end
+      #
+      #   # good
+      #   def attribute
+      #   end
+      class AccessorMethodName < Cop
+        MSG_READER = 'Do not prefix reader method names with `get_`.'
+        MSG_WRITER = 'Do not prefix writer method names with `set_`.'
+
+        def on_def(node)
+          return unless bad_reader_name?(node) || bad_writer_name?(node)
+
+          add_offense(node, location: :name)
+        end
+        alias on_defs on_def
+
+        private
+
+        def message(node)
+          if bad_reader_name?(node)
+            MSG_READER
+          elsif bad_writer_name?(node)
+            MSG_WRITER
+          end
+        end
+
+        def bad_reader_name?(node)
+          node.method_name.to_s.start_with?('get_') && !node.arguments?
+        end
+
+        def bad_writer_name?(node)
+          node.method_name.to_s.start_with?('set_') && node.arguments.one?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/AsciiComments
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks for non-ascii characters in identifier and constant names.
+      # Identifiers are always checked and whether constants are checked
+      # can be controlled using AsciiConstants config.
+      #
+      # @example
+      #   # bad
+      #   def καλημερα # Greek alphabet (non-ascii)
+      #   end
+      #
+      #   # bad
+      #   def こんにちはと言う # Japanese character (non-ascii)
+      #   end
+      #
+      #   # bad
+      #   def hello_🍣 # Emoji (non-ascii)
+      #   end
+      #
+      #   # good
+      #   def say_hello
+      #   end
+      #
+      #   # bad
+      #   신장 = 10 # Hangul character (non-ascii)
+      #
+      #   # good
+      #   height = 10
+      #
+      #   # bad
+      #   params[:عرض_gteq] # Arabic character (non-ascii)
+      #
+      #   # good
+      #   params[:width_gteq]
+      #
+      # @example AsciiConstants: true (default)
+      #   # bad
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
+      # @example AsciiConstants: false
+      #   # good
+      #   class Foö
+      #   end
+      #
+      #   FOÖ = "foo"
+      #
+      class AsciiIdentifiers < Cop
+        include RangeHelp
+
+        IDENTIFIER_MSG = 'Use only ascii symbols in identifiers.'
+        CONSTANT_MSG   = 'Use only ascii symbols in constants.'
+
+        def investigate(processed_source)
+          processed_source.each_token do |token|
+            next if !should_check?(token) || token.text.ascii_only?
+
+            message = token.type == :tIDENTIFIER ? IDENTIFIER_MSG : CONSTANT_MSG
+            add_offense(token, location: first_offense_range(token), message: message)
+          end
+        end
+
+        private
+
+        def should_check?(token)
+          token.type == :tIDENTIFIER ||
+            (token.type == :tCONSTANT && cop_config['AsciiConstants'])
+        end
+
+        def first_offense_range(identifier)
+          expression    = identifier.pos
+          first_offense = first_non_ascii_chars(identifier.text)
+
+          start_position = expression.begin_pos +
+                           identifier.text.index(first_offense)
+          end_position   = start_position + first_offense.length
+
+          range_between(start_position, end_position)
+        end
+
+        def first_non_ascii_chars(string)
+          string.match(/[^[:ascii:]]+/).to_s
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Style/AsciiComments

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that certain binary operator methods have their
+      # sole  parameter named `other`.
+      #
+      # @example
+      #
+      #   # bad
+      #   def +(amount); end
+      #
+      #   # good
+      #   def +(other); end
+      class BinaryOperatorParameterName < Cop
+        MSG = 'When defining the `%<opr>s` operator, ' \
+              'name its argument `other`.'
+
+        OP_LIKE_METHODS = %i[eql? equal?].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === `].freeze
+
+        def_node_matcher :op_method_candidate?, <<~PATTERN
+          (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
+        PATTERN
+
+        def on_def(node)
+          op_method_candidate?(node) do |name, arg|
+            add_offense(arg, message: format(MSG, opr: name))
+          end
+        end
+
+        private
+
+        def op_method?(name)
+          return false if EXCLUDED.include?(name)
+
+          !/\A\w/.match?(name) || OP_LIKE_METHODS.include?(name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/block_parameter_name.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks block parameter names for how descriptive they
+      # are. It is highly configurable.
+      #
+      # The `MinNameLength` config option takes an integer. It represents
+      # the minimum amount of characters the name must be. Its default is 1.
+      # The `AllowNamesEndingInNumbers` config option takes a boolean. When
+      # set to false, this cop will register offenses for names ending with
+      # numbers. Its default is false. The `AllowedNames` config option
+      # takes an array of permitted names that will never register an
+      # offense. The `ForbiddenNames` config option takes an array of
+      # restricted names that will always register an offense.
+      #
+      # @example
+      #   # bad
+      #   bar do |varOne, varTwo|
+      #     varOne + varTwo
+      #   end
+      #
+      #   # With `AllowNamesEndingInNumbers` set to false
+      #   foo { |num1, num2| num1 * num2 }
+      #
+      #   # With `MinParamNameLength` set to number greater than 1
+      #   baz { |a, b, c| do_stuff(a, b, c) }
+      #
+      #   # good
+      #   bar do |thud, fred|
+      #     thud + fred
+      #   end
+      #
+      #   foo { |speed, distance| speed * distance }
+      #
+      #   baz { |age, height, gender| do_stuff(age, height, gender) }
+      class BlockParameterName < Cop
+        include UncommunicativeName
+
+        def on_block(node)
+          return unless node.arguments?
+
+          check(node, node.arguments)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks for class and module names with
+      # an underscore in them.
+      #
+      # `AllowedNames` config takes an array of permitted names.
+      # Its default value is `['module_parent']`.
+      # These names can be full class/module names or part of the name.
+      # eg. Adding `my_class` to the `AllowedNames` config will allow names like
+      # `my_class`, `my_class::User`, `App::my_class`, `App::my_class::User`, etc.
+      #
+      # @example
+      #   # bad
+      #   class My_Class
+      #   end
+      #   module My_Module
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #   end
+      #   module MyModule
+      #   end
+      #   class module_parent::MyModule
+      #   end
+      class ClassAndModuleCamelCase < Cop
+        MSG = 'Use CamelCase for classes and modules.'
+
+        def on_class(node)
+          allowed = /#{cop_config['AllowedNames'].join('|')}/
+          name = node.loc.name.source.gsub(allowed, '')
+          return unless /_/.match?(name)
+
+          add_offense(node, location: :name)
+        end
+        alias on_module on_class
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks whether constant names are written using
+      # SCREAMING_SNAKE_CASE.
+      #
+      # To avoid false positives, it ignores cases in which we cannot know
+      # for certain the type of value that would be assigned to a constant.
+      #
+      # @example
+      #   # bad
+      #   InchInCm = 2.54
+      #   INCHinCM = 2.54
+      #   Inch_In_Cm = 2.54
+      #
+      #   # good
+      #   INCH_IN_CM = 2.54
+      class ConstantName < Cop
+        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'
+        # Use POSIX character classes, so we allow accented characters rather
+        # than just standard ASCII characters
+        SNAKE_CASE = /^[[:digit:][:upper:]_]+$/.freeze
+
+        def_node_matcher :class_or_struct_return_method?, <<~PATTERN
+          (send
+            (const _ {:Class :Struct}) :new
+            ...)
+        PATTERN
+
+        def on_casgn(node)
+          if node.parent&.or_asgn_type?
+            lhs, value = *node.parent
+            _scope, const_name = *lhs
+          else
+            _scope, const_name, value = *node
+          end
+
+          # We cannot know the result of method calls like
+          # NewClass = something_that_returns_a_class
+          # It's also ok to assign a class constant another class constant,
+          # `Class.new(...)` or `Struct.new(...)`
+          # SomeClass = SomeOtherClass
+          # SomeClass = Class.new(...)
+          # SomeClass = Struct.new(...)
+          return if allowed_assignment?(value)
+          return if SNAKE_CASE.match?(const_name)
+
+          add_offense(node, location: :name)
+        end
+
+        private
+
+        def allowed_assignment?(value)
+          value && %i[block const casgn].include?(value.type) ||
+            allowed_method_call_on_rhs?(value) ||
+            class_or_struct_return_method?(value) ||
+            allowed_conditional_expression_on_rhs?(value)
+        end
+
+        def allowed_method_call_on_rhs?(node)
+          node&.send_type? &&
+            (node.receiver.nil? || !literal_receiver?(node))
+        end
+
+        def_node_matcher :literal_receiver?, <<~PATTERN
+          {(send literal? ...)
+           (send (begin literal?) ...)}
+        PATTERN
+
+        def allowed_conditional_expression_on_rhs?(node)
+          node&.if_type? && contains_contant?(node)
+        end
+
+        def contains_contant?(node)
+          node.branches.any?(&:const_type?)
+        end
+      end
+    end
+  end
+end