rubocop 0.75.1

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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that rescued exceptions variables are named as
+      # expected.
+      #
+      # The `PreferredName` config option takes a `String`. It represents
+      # the required name of the variable. Its default is `e`.
+      #
+      # @example PreferredName: e (default)
+      #   # bad
+      #   begin
+      #     # do something
+      #   rescue MyException => exception
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   begin
+      #     # do something
+      #   rescue MyException => e
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   begin
+      #     # do something
+      #   rescue MyException => _e
+      #     # do something
+      #   end
+      #
+      # @example PreferredName: exception
+      #   # bad
+      #   begin
+      #     # do something
+      #   rescue MyException => e
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   begin
+      #     # do something
+      #   rescue MyException => exception
+      #     # do something
+      #   end
+      #
+      #   # good
+      #   begin
+      #     # do something
+      #   rescue MyException => _exception
+      #     # do something
+      #   end
+      #
+      class RescuedExceptionsVariableName < Cop
+        MSG = 'Use `%<preferred>s` instead of `%<bad>s`.'
+
+        def on_resbody(node)
+          name = variable_name(node)
+          return unless name
+          return if preferred_name(name).to_sym == name
+
+          add_offense(node, location: offense_range(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            offending_name = variable_name(node)
+            preferred_name = preferred_name(offending_name)
+            corrector.replace(offense_range(node), preferred_name)
+
+            node.body&.each_descendant(:lvar) do |var|
+              next unless var.children.first == offending_name
+
+              corrector.replace(var.loc.expression, preferred_name)
+            end
+          end
+        end
+
+        private
+
+        def offense_range(resbody)
+          variable = resbody.exception_variable
+          variable.loc.expression
+        end
+
+        def preferred_name(variable_name)
+          preferred_name = cop_config.fetch('PreferredName', 'e')
+          if variable_name.to_s.start_with?('_')
+            "_#{preferred_name}"
+          else
+            preferred_name
+          end
+        end
+
+        def variable_name(node)
+          asgn_node = node.exception_variable
+          return unless asgn_node
+
+          asgn_node.children.last
+        end
+
+        def message(node)
+          offending_name = variable_name(node)
+          preferred_name = preferred_name(offending_name)
+          format(MSG, preferred: preferred_name, bad: offending_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/uncommunicative_block_param_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 whitelisted names that will never register an
+      # offense. The `ForbiddenNames` config option takes an array of
+      # blacklisted 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 UncommunicativeBlockParamName < 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/uncommunicative_method_param_name.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks method 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 3.
+      # 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 whitelisted names that will never register an
+      # offense. The `ForbiddenNames` config option takes an array of
+      # blacklisted names that will always register an offense.
+      #
+      # @example
+      #   # bad
+      #   def bar(varOne, varTwo)
+      #     varOne + varTwo
+      #   end
+      #
+      #   # With `AllowNamesEndingInNumbers` set to false
+      #   def foo(num1, num2)
+      #     num1 * num2
+      #   end
+      #
+      #   # With `MinArgNameLength` set to number greater than 1
+      #   def baz(a, b, c)
+      #     do_stuff(a, b, c)
+      #   end
+      #
+      #   # good
+      #   def bar(thud, fred)
+      #     thud + fred
+      #   end
+      #
+      #   def foo(speed, distance)
+      #     speed * distance
+      #   end
+      #
+      #   def baz(age_a, height_b, gender_c)
+      #     do_stuff(age_a, height_b, gender_c)
+      #   end
+      class UncommunicativeMethodParamName < Cop
+        include UncommunicativeName
+
+        def on_def(node)
+          return unless node.arguments?
+
+          check(node, node.arguments)
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that all variables use the configured style,
+      # snake_case or camelCase, for their names.
+      #
+      # @example EnforcedStyle: snake_case (default)
+      #   # bad
+      #   fooBar = 1
+      #
+      #   # good
+      #   foo_bar = 1
+      #
+      # @example EnforcedStyle: camelCase
+      #   # bad
+      #   foo_bar = 1
+      #
+      #   # good
+      #   fooBar = 1
+      class VariableName < Cop
+        include ConfigurableNaming
+
+        MSG = 'Use %<style>s for variable names.'
+
+        def on_lvasgn(node)
+          name, = *node
+          return unless name
+
+          check_name(node, name, node.loc.name)
+        end
+        alias on_ivasgn    on_lvasgn
+        alias on_cvasgn    on_lvasgn
+        alias on_arg       on_lvasgn
+        alias on_optarg    on_lvasgn
+        alias on_restarg   on_lvasgn
+        alias on_kwoptarg  on_lvasgn
+        alias on_kwarg     on_lvasgn
+        alias on_kwrestarg on_lvasgn
+        alias on_blockarg  on_lvasgn
+        alias on_lvar      on_lvasgn
+
+        private
+
+        def message(style)
+          format(MSG, style: style)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that all numbered variables use the
+      # configured style, snake_case, normalcase, or non_integer,
+      # for their numbering.
+      #
+      # @example EnforcedStyle: snake_case
+      #   # bad
+      #
+      #   variable1 = 1
+      #
+      #   # good
+      #
+      #   variable_1 = 1
+      #
+      # @example EnforcedStyle: normalcase (default)
+      #   # bad
+      #
+      #   variable_1 = 1
+      #
+      #   # good
+      #
+      #   variable1 = 1
+      #
+      # @example EnforcedStyle: non_integer
+      #   # bad
+      #
+      #   variable1 = 1
+      #
+      #   variable_1 = 1
+      #
+      #   # good
+      #
+      #   variableone = 1
+      #
+      #   variable_one = 1
+      class VariableNumber < Cop
+        include ConfigurableNumbering
+
+        MSG = 'Use %<style>s for variable numbers.'
+
+        def on_arg(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+        alias on_lvasgn on_arg
+        alias on_ivasgn on_arg
+        alias on_cvasgn on_arg
+
+        private
+
+        def message(style)
+          format(MSG, style: style)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/offense.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # An offense represents a style violation detected by RuboCop.
+    class Offense
+      include Comparable
+
+      # @api private
+      COMPARISON_ATTRIBUTES = %i[line column cop_name
+                                 message severity].freeze
+
+      # @api public
+      #
+      # @!attribute [r] severity
+      #
+      # @return [RuboCop::Cop::Severity]
+      attr_reader :severity
+
+      # @api public
+      #
+      # @!attribute [r] location
+      #
+      # @return [Parser::Source::Range]
+      #   the location where the violation is detected.
+      #
+      # @see https://www.rubydoc.info/gems/parser/Parser/Source/Range
+      #   Parser::Source::Range
+      attr_reader :location
+
+      # @api public
+      #
+      # @!attribute [r] message
+      #
+      # @return [String]
+      #   human-readable message
+      #
+      # @example
+      #   'Line is too long. [90/80]'
+      attr_reader :message
+
+      # @api public
+      #
+      # @!attribute [r] cop_name
+      #
+      # @return [String]
+      #   a cop class name without department.
+      #   i.e. type of the violation.
+      #
+      # @example
+      #   'LineLength'
+      attr_reader :cop_name
+
+      # @api private
+      attr_reader :status
+
+      # @api private
+      def initialize(severity, location, message, cop_name,
+                     status = :uncorrected)
+        @severity = RuboCop::Cop::Severity.new(severity)
+        @location = location
+        @message = message.freeze
+        @cop_name = cop_name.freeze
+        @status = status
+        freeze
+      end
+
+      # @api public
+      #
+      # @!attribute [r] corrected?
+      #
+      # @return [Boolean]
+      #   whether this offense is automatically corrected via
+      #   autocorrect or a todo.
+      def corrected?
+        @status == :corrected || @status == :corrected_with_todo
+      end
+
+      # @api public
+      #
+      # @!attribute [r] corrected_with_todo?
+      #
+      # @return [Boolean]
+      #   whether this offense is automatically disabled via a todo.
+      def corrected_with_todo?
+        @status == :corrected_with_todo
+      end
+
+      # @api public
+      #
+      # @!attribute [r] disabled?
+      #
+      # @return [Boolean]
+      #   whether this offense was locally disabled with a
+      #   disable or todo where it occurred.
+      def disabled?
+        @status == :disabled || @status == :todo
+      end
+
+      # @api public
+      #
+      # @return [Parser::Source::Range]
+      #   the range of the code that is highlighted
+      def highlighted_area
+        Parser::Source::Range.new(source_line,
+                                  column,
+                                  column + column_length)
+      end
+
+      # @api private
+      # This is just for debugging purpose.
+      def to_s
+        format('%<severity>s:%3<line>d:%3<column>d: %<message>s',
+               severity: severity.code, line: line,
+               column: real_column, message: message)
+      end
+
+      # @api private
+      def line
+        location.line
+      end
+
+      # @api private
+      def column
+        location.column
+      end
+
+      # @api private
+      def source_line
+        location.source_line
+      end
+
+      # @api private
+      def column_length
+        if first_line == last_line
+          column_range.count
+        else
+          source_line.length - column
+        end
+      end
+
+      # @api private
+      def first_line
+        location.first_line
+      end
+
+      # @api private
+      def last_line
+        location.last_line
+      end
+
+      # @api private
+      def last_column
+        location.last_column
+      end
+
+      # @api private
+      def column_range
+        location.column_range
+      end
+
+      # @api private
+      #
+      # Internally we use column number that start at 0, but when
+      # outputting column numbers, we want them to start at 1. One
+      # reason is that editors, such as Emacs, expect this.
+      def real_column
+        column + 1
+      end
+
+      # @api public
+      #
+      # @return [Boolean]
+      #   returns `true` if two offenses contain same attributes
+      def ==(other)
+        COMPARISON_ATTRIBUTES.all? do |attribute|
+          send(attribute) == other.send(attribute)
+        end
+      end
+
+      alias eql? ==
+
+      def hash
+        COMPARISON_ATTRIBUTES.reduce(0) do |hash, attribute|
+          hash ^ send(attribute).hash
+        end
+      end
+
+      # @api public
+      #
+      # Returns `-1`, `0`, or `+1`
+      # if this offense is less than, equal to, or greater than `other`.
+      #
+      # @return [Integer]
+      #   comparison result
+      def <=>(other)
+        COMPARISON_ATTRIBUTES.each do |attribute|
+          result = send(attribute) <=> other.send(attribute)
+          return result unless result.zero?
+        end
+        0
+      end
+    end
+  end
+end