rbhint 0.8.5.rc1

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/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

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

@@ -0,0 +1,225 @@
+# 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)
+
+          if filename_good?(basename)
+            msg = perform_class_and_module_naming_checks(file_path, basename)
+          else
+            msg = other_message(basename) unless bad_filename_allowed?
+          end
+
+          yield source_range(processed_source.buffer, 1, 0), msg if msg
+        end
+
+        def perform_class_and_module_naming_checks(file_path, basename)
+          return unless expect_matching_definition?
+
+          if check_definition_path_hierarchy? &&
+             !matching_definition?(file_path)
+            msg = no_definition_message(basename, file_path)
+          elsif !matching_class?(basename)
+            msg = no_definition_message(basename, basename)
+          end
+          msg
+        end
+
+        def matching_definition?(file_path)
+          find_class_or_module(processed_source.ast, to_namespace(file_path))
+        end
+
+        def matching_class?(file_name)
+          find_class_or_module(processed_source.ast, to_namespace(file_name))
+        end
+
+        def bad_filename_allowed?
+          ignore_executable_scripts? && processed_source.start_with?('#!')
+        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 check_definition_path_hierarchy?
+          cop_config['CheckDefinitionPathHierarchy']
+        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
+
+              expected.pop if name == expected.last || match_acronym?(expected.last, name)
+            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