rubocop 0.75.1

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality shared by Uncommunicative cops
+    module UncommunicativeName
+      CASE_MSG = 'Only use lowercase characters for %<name_type>s.'
+      NUM_MSG = 'Do not end %<name_type>s with a number.'
+      LENGTH_MSG = '%<name_type>s must be at least %<min>s ' \
+                   'characters long.'
+      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a ' \
+                      '%<name_type>s.'
+
+      def check(node, args)
+        args.each do |arg|
+          # Argument names might be "_" or prefixed with "_" to indicate they
+          # are unused. Trim away this prefix and only analyse the basename.
+          full_name = arg.children.first.to_s
+          next if full_name == '_'
+
+          name = full_name.gsub(/\A([_]+)/, '')
+          next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
+          next if allowed_names.include?(name)
+
+          range = arg_range(arg, name.size)
+          issue_offenses(node, range, name)
+        end
+      end
+
+      private
+
+      def issue_offenses(node, range, name)
+        forbidden_offense(node, range, name) if forbidden_names.include?(name)
+        case_offense(node, range) if uppercase?(name)
+        length_offense(node, range) unless long_enough?(name)
+        return if allow_nums
+
+        num_offense(node, range) if ends_with_num?(name)
+      end
+
+      def case_offense(node, range)
+        add_offense(node, location: range,
+                          message: format(CASE_MSG, name_type: name_type(node)))
+      end
+
+      def uppercase?(name)
+        name =~ /[[:upper:]]/
+      end
+
+      def name_type(node)
+        @name_type ||= begin
+          case node.type
+          when :block then 'block parameter'
+          when :def, :defs then 'method parameter'
+          end
+        end
+      end
+
+      def num_offense(node, range)
+        add_offense(node, location: range,
+                          message: format(NUM_MSG, name_type: name_type(node)))
+      end
+
+      def ends_with_num?(name)
+        name[-1] =~ /\d/
+      end
+
+      def length_offense(node, range)
+        add_offense(node, location: range,
+                          message: format(LENGTH_MSG,
+                                          name_type: name_type(node).capitalize,
+                                          min: min_length))
+      end
+
+      def long_enough?(name)
+        name.size >= min_length
+      end
+
+      def arg_range(arg, length)
+        begin_pos = arg.source_range.begin_pos
+        Parser::Source::Range.new(processed_source.buffer,
+                                  begin_pos,
+                                  begin_pos + length)
+      end
+
+      def forbidden_offense(node, range, name)
+        add_offense(
+          node,
+          location: range,
+          message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node))
+        )
+      end
+
+      def allowed_names
+        cop_config['AllowedNames']
+      end
+
+      def forbidden_names
+        cop_config['ForbiddenNames']
+      end
+
+      def allow_nums
+        cop_config['AllowNamesEndingInNumbers']
+      end
+
+      def min_length
+        cop_config['MinNameLength']
+      end
+    end
+  end
+end

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/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,72 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/AsciiComments
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks for non-ascii characters in identifier names.
+      #
+      # @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]
+      #
+      class AsciiIdentifiers < Cop
+        include RangeHelp
+
+        MSG = 'Use only ascii symbols in identifiers.'
+
+        def investigate(processed_source)
+          processed_source.each_token do |token|
+            next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
+
+            add_offense(token, location: first_offense_range(token))
+          end
+        end
+
+        private
+
+        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
+        BLACKLISTED = %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 BLACKLISTED.include?(name)
+
+          name !~ /\A\w/ || OP_LIKE_METHODS.include?(name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks for class and module names with
+      # an underscore in them.
+      #
+      # @example
+      #   # bad
+      #   class My_Class
+      #   end
+      #   module My_Module
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #   end
+      #   module MyModule
+      #   end
+      class ClassAndModuleCamelCase < Cop
+        MSG = 'Use CamelCase for classes and modules.'
+
+        def on_class(node)
+          return unless node.loc.name.source =~ /_/
+
+          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,81 @@
+# 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)
+
+          add_offense(node, location: :name) if const_name !~ SNAKE_CASE
+        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

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

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that Ruby source files have snake_case
+      # names. Ruby scripts (i.e. source files with a shebang in the
+      # first line) are ignored.
+      #
+      # The cop also ignores `.gemspec` files, because Bundler
+      # recommends using dashes to separate namespaces in nested gems
+      # (i.e. `bundler-console` becomes `Bundler::Console`). As such, the
+      # gemspec is supposed to be named `bundler-console.gemspec`.
+      #
+      # @example
+      #   # bad
+      #   lib/layoutManager.rb
+      #
+      #   anything/usingCamelCase
+      #
+      #   # good
+      #   lib/layout_manager.rb
+      #
+      #   anything/using_snake_case.rake
+      class FileName < Cop
+        include RangeHelp
+
+        MSG_SNAKE_CASE = 'The name of this source file (`%<basename>s`) ' \
+                         'should use snake_case.'
+        MSG_NO_DEFINITION = '%<basename>s should define a class or module ' \
+                            'called `%<namespace>s`.'
+        MSG_REGEX = '`%<basename>s` should match `%<regex>s`.'
+
+        SNAKE_CASE = /^[\da-z_.?!]+$/.freeze
+
+        def investigate(processed_source)
+          file_path = processed_source.file_path
+          return if config.file_to_exclude?(file_path) ||
+                    config.allowed_camel_case_file?(file_path)
+
+          for_bad_filename(file_path) do |range, msg|
+            add_offense(nil, location: range, message: msg)
+          end
+        end
+
+        private
+
+        def for_bad_filename(file_path)
+          basename = File.basename(file_path)
+          msg = if filename_good?(basename)
+                  return unless expect_matching_definition?
+                  return if find_class_or_module(processed_source.ast,
+                                                 to_namespace(file_path))
+
+                  no_definition_message(basename, file_path)
+                else
+                  return if ignore_executable_scripts? &&
+                            processed_source.start_with?('#!')
+
+                  other_message(basename)
+                end
+
+          yield source_range(processed_source.buffer, 1, 0), msg
+        end
+
+        def no_definition_message(basename, file_path)
+          format(MSG_NO_DEFINITION,
+                 basename: basename,
+                 namespace: to_namespace(file_path).join('::'))
+        end
+
+        def other_message(basename)
+          if regex
+            format(MSG_REGEX, basename: basename, regex: regex)
+          else
+            format(MSG_SNAKE_CASE, basename: basename)
+          end
+        end
+
+        def ignore_executable_scripts?
+          cop_config['IgnoreExecutableScripts']
+        end
+
+        def expect_matching_definition?
+          cop_config['ExpectMatchingDefinition']
+        end
+
+        def regex
+          cop_config['Regex']
+        end
+
+        def allowed_acronyms
+          cop_config['AllowedAcronyms'] || []
+        end
+
+        def filename_good?(basename)
+          basename = basename.sub(/^\./, '')
+          basename = basename.sub(/\.[^\.]+$/, '')
+          # special handling for Action Pack Variants file names like
+          # some_file.xlsx+mobile.axlsx
+          basename = basename.sub('+', '_')
+          basename =~ (regex || SNAKE_CASE)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def find_class_or_module(node, namespace)
+          return nil unless node
+
+          name = namespace.pop
+
+          on_node(%i[class module casgn], node) do |child|
+            next unless (const = child.defined_module)
+
+            const_namespace, const_name = *const
+            next if name != const_name && !match_acronym?(name, const_name)
+            next unless namespace.empty? ||
+                        match_namespace(child, const_namespace, namespace)
+
+            return node
+          end
+
+          nil
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def match_namespace(node, namespace, expected)
+          match_partial = partial_matcher!(expected)
+
+          match_partial.call(namespace)
+
+          node.each_ancestor(:class, :module, :sclass, :casgn) do |ancestor|
+            return false if ancestor.sclass_type?
+
+            match_partial.call(ancestor.defined_module)
+          end
+
+          match?(expected)
+        end
+
+        def partial_matcher!(expected)
+          lambda do |namespace|
+            while namespace
+              return match?(expected) if namespace.cbase_type?
+
+              namespace, name = *namespace
+
+              if name == expected.last || match_acronym?(expected.last, name)
+                expected.pop
+              end
+            end
+
+            false
+          end
+        end
+
+        def match?(expected)
+          expected.empty? || expected == [:Object]
+        end
+
+        def match_acronym?(expected, name)
+          expected = expected.to_s
+          name = name.to_s
+
+          allowed_acronyms.any? do |acronym|
+            expected.gsub(acronym.capitalize, acronym) == name
+          end
+        end
+
+        def to_namespace(path)
+          components = Pathname(path).each_filename.to_a
+          # To convert a pathname to a Ruby namespace, we need a starting point
+          # But RC can be run from any working directory, and can check any path
+          # We can't assume that the working directory, or any other, is the
+          # "starting point" to build a namespace.
+          start = %w[lib spec test src]
+          start_index = nil
+
+          # To find the closest namespace root take the path components, and
+          # then work through them backwards until we find a candidate. This
+          # makes sure we work from the actual root in the case of a path like
+          # /home/user/src/project_name/lib.
+          components.reverse.each_with_index do |c, i|
+            if start.include?(c)
+              start_index = components.size - i
+              break
+            end
+          end
+
+          if start_index.nil?
+            [to_module_name(components.last)]
+          else
+            components[start_index..-1].map { |c| to_module_name(c) }
+          end
+        end
+
+        def to_module_name(basename)
+          words = basename.sub(/\..*/, '').split('_')
+          words.map(&:capitalize).join.to_sym
+        end
+      end
+    end
+  end
+end