rubocop 0.49.1 → 0.52.0

data/lib/rubocop/cop/layout/space_inside_brackets.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for spaces inside square brackets.
-      class SpaceInsideBrackets < Cop
-        include SpaceInside
-
-        def specifics
-          [
-            %i[tLBRACK tLBRACK2],
-            :tRBRACK,
-            'square brackets'
-          ]
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/lint/invalid_character_literal.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for invalid character literals with a non-escaped
-      # whitespace character (e.g. `? `).
-      # However, currently it's unclear whether there's a way to emit this
-      # warning without syntax errors.
-      #
-      #     $ ruby -w
-      #     p(? )
-      #     -:1: warning: invalid character syntax; use ?\s
-      #     -:1: syntax error, unexpected '?', expecting ')'
-      #     p(? )
-      #        ^
-      #
-      # @example
-      #
-      #   # bad
-      #
-      #   p(? )
-      class InvalidCharacterLiteral < Cop
-        include ParserDiagnostic
-
-        private
-
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :invalid_escape_use
-        end
-
-        def alternative_message(diagnostic)
-          diagnostic
-            .message
-            .capitalize
-            .gsub('character syntax', 'character literal')
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking modifier nodes.
-    module AccessModifierNode
-      extend NodePattern::Macros
-
-      def_node_matcher :private_node?, '(send nil :private)'
-      def_node_matcher :protected_node?, '(send nil :protected)'
-      def_node_matcher :public_node?, '(send nil :public)'
-      def_node_matcher :module_function_node?, '(send nil :module_function)'
-
-      # Returns true when the node is an access modifier.
-      def modifier_node?(node)
-        modifier_structure?(node) && class_or_module_parent?(node)
-      end
-
-      # Returns true when the node looks like an access modifier.
-      def modifier_structure?(node)
-        private_node?(node) ||
-          protected_node?(node) ||
-          public_node?(node) ||
-          module_function_node?(node)
-      end
-
-      # Returns true when the parent of what looks like an access modifier
-      # is a Class or Module. Filters out simple method calls to similarly
-      # named private, protected or public.
-      def class_or_module_parent?(node)
-        node.each_ancestor do |ancestor|
-          if ancestor.block_type?
-            return true if ancestor.class_constructor?
-          elsif !ancestor.begin_type?
-            return %i[casgn sclass class module].include?(ancestor.type)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking instance methods and singleton methods.
-    module OnMethodDef
-      def on_def(node)
-        method_name, args, body = *node
-        on_method_def(node, method_name, args, body)
-      end
-
-      def on_defs(node)
-        _scope, method_name, args, body = *node
-        on_method_def(node, method_name, args, body)
-      end
-
-      # This method provides scope agnostic method node destructuring by moving
-      # the scope to the end where it can easily be ignored.
-      def method_def_node_parts(node)
-        if node.def_type?
-          method_name, args, body = *node
-        elsif node.defs_type?
-          scope, method_name, args, body = *node
-        else
-          return []
-        end
-
-        [method_name, args, body, scope]
-      end
-
-      private
-
-      # Returns true for constructs such as
-      # private def my_method
-      # which are allowed in Ruby 2.1 and later.
-      def modifier_and_def_on_same_line?(send_node)
-        !send_node.receiver &&
-          send_node.method_name != :def &&
-          send_node.arguments.one? &&
-          %i[def defs].include?(send_node.first_argument.type)
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking for spaces inside various
-    # kinds of brackets.
-    module SpaceInside
-      include SurroundingSpace
-      MSG = 'Space inside %s detected.'.freeze
-
-      def investigate(processed_source)
-        @processed_source = processed_source
-        each_extraneous_space(processed_source.tokens) do |kind, range|
-          add_offense(range, range, format(MSG, kind))
-        end
-      end
-
-      def autocorrect(range)
-        ->(corrector) { corrector.remove(range) }
-      end
-
-      private
-
-      def each_extraneous_space(tokens)
-        brackets = Brackets.new(*specifics)
-        tokens.each_cons(2) do |t1, t2|
-          next unless matching_brackets?(brackets, t1, t2)
-
-          # If the second token is a comment, that means that a line break
-          # follows, and that the rules for space inside don't apply.
-          next if t2.type == :tCOMMENT
-          next unless t2.pos.line == t1.pos.line && space_between?(t1, t2)
-
-          yield brackets.kind, range_between_tokens(t1, t2)
-        end
-      end
-
-      def matching_brackets?(brackets, t1, t2)
-        brackets.left_side?(t1) || brackets.right_side?(t2)
-      end
-
-      def range_between_tokens(t1, t2)
-        range_between(t1.pos.end_pos, t2.pos.begin_pos)
-      end
-
-      # Wraps info about the brackets. Makes it easy to check whether a token
-      # is one of the brackets.
-      #
-      # @example Parentheses `()`
-      #   Brackets.new(:tLPAREN, :tRPAREN, 'parentheses')
-      #
-      # @example Square brackets `[]`
-      #   Brackets.new([:tLBRACK, :tLBRACK2], :tRBRACK, 'square brackets')
-      #
-      class Brackets
-        attr_reader :kind
-
-        def initialize(left, right, kind)
-          @left_side_types = [left].flatten
-          @right_side_type = right
-          @kind = kind
-        end
-
-        def left_side?(token)
-          # Left side bracket has to be able to match multiple types
-          # (e.g. :tLBRACK and :tLBRACK2)
-          @left_side_types.include?(token.type)
-        end
-
-        def right_side?(token)
-          @right_side_type == token.type
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop makes sure that accessor methods are named properly.
-      #
-      # @example
-      #   # bad
-      #   def set_attribute(value) ...
-      #
-      #   # good
-      #   def attribute=(value)
-      #
-      #   # bad
-      #   def get_attribute ...
-      #
-      #   # good
-      #   def attribute ...
-      class AccessorMethodName < Cop
-        include OnMethodDef
-
-        private
-
-        def on_method_def(node, method_name, args, _body)
-          if bad_reader_name?(method_name.to_s, args)
-            add_offense(node, :name,
-                        'Do not prefix reader method names with `get_`.')
-          elsif bad_writer_name?(method_name.to_s, args)
-            add_offense(node, :name,
-                        'Do not prefix writer method names with `set_`.')
-          end
-        end
-
-        def bad_reader_name?(method_name, args)
-          method_name.start_with?('get_') && args.to_a.empty?
-        end
-
-        def bad_writer_name?(method_name, args)
-          method_name.start_with?('set_') && args.to_a.one?
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  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/rubocop/cop/style/constant_name.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # 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.
-      class ConstantName < Cop
-        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'.freeze
-        SNAKE_CASE = /^[\dA-Z_]+$/
-
-        def on_casgn(node)
-          _scope, const_name, value = *node
-
-          # 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
-          # SomeClass = SomeOtherClass
-          return if value && %i[send block const].include?(value.type)
-
-          add_offense(node, :name) if const_name !~ SNAKE_CASE
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop makes sure that all methods use the configured style,
-      # snake_case or camelCase, for their names. Some special arrangements
-      # have to be made for operator methods.
-      class MethodName < Cop
-        include ConfigurableNaming
-
-        def on_def(node)
-          name, = *node
-          check_name(node, sanitize_name(name), node.loc.name)
-        end
-
-        def on_defs(node)
-          _object, name, = *node
-          check_name(node, sanitize_name(name), node.loc.name)
-        end
-
-        private
-
-        def message(style)
-          format('Use %s for method names.', style)
-        end
-
-        def sanitize_name(name)
-          name.to_s.delete('@').to_sym
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop makes sure that predicates are named properly.
-      #
-      # @example
-      #   # bad
-      #   def is_even?(value) ...
-      #
-      #   # good
-      #   def even?(value)
-      #
-      #   # bad
-      #   def has_value? ...
-      #
-      #   # good
-      #   def value? ...
-      class PredicateName < Cop
-        include OnMethodDef
-
-        private
-
-        def on_method_def(node, method_name, _args, _body)
-          predicate_prefixes.each do |prefix|
-            method_name = method_name.to_s
-            next unless method_name.start_with?(prefix)
-            next if method_name == expected_name(method_name, prefix)
-            next if predicate_whitelist.include?(method_name)
-            add_offense(
-              node,
-              :name,
-              message(method_name, expected_name(method_name, prefix))
-            )
-          end
-        end
-
-        def expected_name(method_name, prefix)
-          new_name = if prefix_blacklist.include?(prefix)
-                       method_name.sub(prefix, '')
-                     else
-                       method_name.dup
-                     end
-          new_name << '?' unless method_name.end_with?('?')
-          new_name
-        end
-
-        def message(method_name, new_name)
-          "Rename `#{method_name}` to `#{new_name}`."
-        end
-
-        def prefix_blacklist
-          cop_config['NamePrefixBlacklist']
-        end
-
-        def predicate_prefixes
-          cop_config['NamePrefix']
-        end
-
-        def predicate_whitelist
-          cop_config['NameWhitelist']
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop makes sure that all variables use the configured style,
-      # snake_case or camelCase, for their names.
-      class VariableName < Cop
-        include ConfigurableNaming
-
-        def on_lvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_ivasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_cvasgn(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        def on_arg(node)
-          name, = *node
-          check_name(node, name, node.loc.name)
-        end
-
-        private
-
-        def message(style)
-          format('Use %s for variable names.', style)
-        end
-      end
-    end
-  end
-end