rubocop 0.87.1

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop is used to identify usages of `shuffle.first`,
+      # `shuffle.last`, and `shuffle[]` and change them to use
+      # `sample` instead.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].shuffle.first
+      #   [1, 2, 3].shuffle.first(2)
+      #   [1, 2, 3].shuffle.last
+      #   [2, 1, 3].shuffle.at(0)
+      #   [2, 1, 3].shuffle.slice(0)
+      #   [1, 2, 3].shuffle[2]
+      #   [1, 2, 3].shuffle[0, 2]    # sample(2) will do the same
+      #   [1, 2, 3].shuffle[0..2]    # sample(3) will do the same
+      #   [1, 2, 3].shuffle(random: Random.new).first
+      #
+      #   # good
+      #   [1, 2, 3].shuffle
+      #   [1, 2, 3].sample
+      #   [1, 2, 3].sample(3)
+      #   [1, 2, 3].shuffle[1, 3]    # sample(3) might return a longer Array
+      #   [1, 2, 3].shuffle[1..3]    # sample(3) might return a longer Array
+      #   [1, 2, 3].shuffle[foo, bar]
+      #   [1, 2, 3].shuffle(random: Random.new)
+      class Sample < Cop
+        MSG = 'Use `%<correct>s` instead of `%<incorrect>s`.'
+
+        def_node_matcher :sample_candidate?, <<~PATTERN
+          (send $(send _ :shuffle $...) ${:first :last :[] :at :slice} $...)
+        PATTERN
+
+        def on_send(node)
+          sample_candidate?(node) do |shuffle, shuffle_arg, method, method_args|
+            return unless offensive?(method, method_args)
+
+            range = source_range(shuffle, node)
+            message = message(shuffle_arg, method, method_args, range)
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          shuffle_node, shuffle_arg, method, method_args =
+            sample_candidate?(node)
+
+          lambda do |corrector|
+            corrector.replace(source_range(shuffle_node, node),
+                              correction(shuffle_arg, method, method_args))
+          end
+        end
+
+        private
+
+        def offensive?(method, method_args)
+          case method
+          when :first, :last
+            true
+          when :[], :at, :slice
+            sample_size(method_args) != :unknown
+          else
+            false
+          end
+        end
+
+        def sample_size(method_args)
+          case method_args.size
+          when 1
+            sample_size_for_one_arg(method_args.first)
+          when 2
+            sample_size_for_two_args(*method_args)
+          end
+        end
+
+        def sample_size_for_one_arg(arg)
+          if arg.range_type?
+            range_size(arg)
+          elsif arg.int_type?
+            [0, -1].include?(arg.to_a.first) ? nil : :unknown
+          else
+            :unknown
+          end
+        end
+
+        def sample_size_for_two_args(first, second)
+          return :unknown unless first.int_type? && first.to_a.first.zero?
+
+          second.int_type? ? second.to_a.first : :unknown
+        end
+
+        def range_size(range_node) # rubocop:todo Metrics/CyclomaticComplexity
+          vals = range_node.to_a
+          return :unknown unless vals.all?(&:int_type?)
+
+          low, high = vals.map { |val| val.children[0] }
+          return :unknown unless low.zero? && high >= 0
+
+          case range_node.type
+          when :erange
+            (low...high).size
+          when :irange
+            (low..high).size
+          end
+        end
+
+        def source_range(shuffle_node, node)
+          Parser::Source::Range.new(shuffle_node.source_range.source_buffer,
+                                    shuffle_node.loc.selector.begin_pos,
+                                    node.source_range.end_pos)
+        end
+
+        def message(shuffle_arg, method, method_args, range)
+          format(MSG,
+                 correct: correction(shuffle_arg, method, method_args),
+                 incorrect: range.source)
+        end
+
+        def correction(shuffle_arg, method, method_args)
+          shuffle_arg = extract_source(shuffle_arg)
+          sample_arg = sample_arg(method, method_args)
+          args = [sample_arg, shuffle_arg].compact.join(', ')
+          args.empty? ? 'sample' : "sample(#{args})"
+        end
+
+        def sample_arg(method, method_args)
+          case method
+          when :first, :last
+            extract_source(method_args)
+          when :[], :slice
+            sample_size(method_args)
+          end
+        end
+
+        def extract_source(args)
+          args.empty? ? nil : args.first.source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use the shorthand for self-assignment.
+      #
+      # @example
+      #
+      #   # bad
+      #   x = x + 1
+      #
+      #   # good
+      #   x += 1
+      class SelfAssignment < Cop
+        MSG = 'Use self-assignment shorthand `%<method>s=`.'
+        OPS = %i[+ - * ** / | &].freeze
+
+        def self.autocorrect_incompatible_with
+          [Layout::SpaceAroundOperators]
+        end
+
+        def on_lvasgn(node)
+          check(node, :lvar)
+        end
+
+        def on_ivasgn(node)
+          check(node, :ivar)
+        end
+
+        def on_cvasgn(node)
+          check(node, :cvar)
+        end
+
+        def autocorrect(node)
+          _var_name, rhs = *node
+
+          if rhs.send_type?
+            autocorrect_send_node(node, rhs)
+          elsif %i[and or].include?(rhs.type)
+            autocorrect_boolean_node(node, rhs)
+          end
+        end
+
+        private
+
+        def check(node, var_type)
+          var_name, rhs = *node
+          return unless rhs
+
+          if rhs.send_type?
+            check_send_node(node, rhs, var_name, var_type)
+          elsif %i[and or].include?(rhs.type)
+            check_boolean_node(node, rhs, var_name, var_type)
+          end
+        end
+
+        def check_send_node(node, rhs, var_name, var_type)
+          receiver, method_name, *_args = *rhs
+          return unless OPS.include?(method_name)
+
+          target_node = s(var_type, var_name)
+          return unless receiver == target_node
+
+          add_offense(node, message: format(MSG, method: method_name))
+        end
+
+        def check_boolean_node(node, rhs, var_name, var_type)
+          first_operand, _second_operand = *rhs
+
+          target_node = s(var_type, var_name)
+          return unless first_operand == target_node
+
+          operator = rhs.loc.operator.source
+          add_offense(node, message: format(MSG, method: operator))
+        end
+
+        def autocorrect_send_node(node, rhs)
+          _receiver, method_name, args = *rhs
+          apply_autocorrect(node, rhs, method_name.to_s, args)
+        end
+
+        def autocorrect_boolean_node(node, rhs)
+          _first_operand, second_operand = *rhs
+          apply_autocorrect(node, rhs, rhs.loc.operator.source, second_operand)
+        end
+
+        def apply_autocorrect(node, rhs, operator, new_rhs)
+          lambda do |corrector|
+            corrector.insert_before(node.loc.operator, operator)
+            corrector.replace(rhs, new_rhs.source)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for multiple expressions placed on the same line.
+      # It also checks for lines terminated with a semicolon.
+      #
+      # This cop has `AllowAsExpressionSeparator` configuration option.
+      # It allows `;` to separate several expressions on the same line.
+      #
+      # @example
+      #   # bad
+      #   foo = 1; bar = 2;
+      #   baz = 3;
+      #
+      #   # good
+      #   foo = 1
+      #   bar = 2
+      #   baz = 3
+      #
+      # @example AllowAsExpressionSeparator: false (default)
+      #   # bad
+      #   foo = 1; bar = 2
+      #
+      # @example AllowAsExpressionSeparator: true
+      #   # good
+      #   foo = 1; bar = 2
+      class Semicolon < Cop
+        include RangeHelp
+
+        MSG = 'Do not use semicolons to terminate expressions.'
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+
+          @processed_source = processed_source
+
+          check_for_line_terminator_or_opener
+        end
+
+        def on_begin(node) # rubocop:todo Metrics/CyclomaticComplexity
+          return if cop_config['AllowAsExpressionSeparator']
+
+          exprs = node.children
+
+          return if exprs.size < 2
+
+          # create a map matching lines to the number of expressions on them
+          exprs_lines = exprs.map(&:first_line)
+          lines = exprs_lines.group_by(&:itself)
+
+          lines.each do |line, expr_on_line|
+            # Every line with more than one expression on it is a
+            # potential offense
+            next unless expr_on_line.size > 1
+
+            # TODO: Find the correct position of the semicolon. We don't know
+            # if the first semicolon on the line is a separator of
+            # expressions. It's just a guess.
+            column = @processed_source[line - 1].index(';')
+
+            next unless column
+
+            convention_on(line, column, false)
+          end
+        end
+
+        def autocorrect(range)
+          return unless range
+
+          ->(corrector) { corrector.remove(range) }
+        end
+
+        private
+
+        def check_for_line_terminator_or_opener
+          each_semicolon { |line, column| convention_on(line, column, true) }
+        end
+
+        def each_semicolon
+          tokens_for_lines.each do |line, tokens|
+            yield line, tokens.last.column if tokens.last.semicolon?
+            yield line, tokens.first.column if tokens.first.semicolon?
+          end
+        end
+
+        def tokens_for_lines
+          @processed_source.tokens.group_by(&:line)
+        end
+
+        def convention_on(line, column, autocorrect)
+          range = source_range(@processed_source.buffer, line, column)
+          # Don't attempt to autocorrect if semicolon is separating statements
+          # on the same line
+          add_offense(autocorrect ? range : nil, location: range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of the send method.
+      #
+      # @example
+      #   # bad
+      #   Foo.send(:bar)
+      #   quuz.send(:fred)
+      #
+      #   # good
+      #   Foo.__send__(:bar)
+      #   quuz.public_send(:fred)
+      class Send < Cop
+        MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
+              '`send`.'
+
+        def_node_matcher :sending?, '({send csend} _ :send ...)'
+
+        def on_send(node)
+          return unless sending?(node) && node.arguments?
+
+          add_offense(node, location: :selector)
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of `fail` and `raise`.
+      #
+      # @example EnforcedStyle: only_raise (default)
+      #   # The `only_raise` style enforces the sole use of `raise`.
+      #   # bad
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.fail
+      #
+      #   # good
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.raise
+      #
+      # @example EnforcedStyle: only_fail
+      #   # The `only_fail` style enforces the sole use of `fail`.
+      #   # bad
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.raise
+      #
+      #   # good
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   Kernel.fail
+      #
+      # @example EnforcedStyle: semantic
+      #   # The `semantic` style enforces the use of `fail` to signal an
+      #   # exception, then will use `raise` to trigger an offense after
+      #   # it has been rescued.
+      #   # bad
+      #   begin
+      #     raise
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     # Error thrown
+      #   rescue Exception
+      #     fail
+      #   end
+      #
+      #   Kernel.fail
+      #   Kernel.raise
+      #
+      #   # good
+      #   begin
+      #     fail
+      #   rescue Exception
+      #     # handle it
+      #   end
+      #
+      #   def watch_out
+      #     fail
+      #   rescue Exception
+      #     raise 'Preferably with descriptive message'
+      #   end
+      #
+      #   explicit_receiver.fail
+      #   explicit_receiver.raise
+      class SignalException < Cop
+        include ConfigurableEnforcedStyle
+
+        FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
+        RAISE_MSG = 'Use `raise` instead of `fail` to ' \
+                    'rethrow exceptions.'
+
+        def_node_matcher :kernel_call?, '(send (const {nil? cbase} :Kernel) %1 ...)'
+        def_node_search :custom_fail_methods,
+                        '{(def :fail ...) (defs _ :fail ...)}'
+
+        def investigate(processed_source)
+          ast = processed_source.ast
+          @custom_fail_defined = ast && custom_fail_methods(ast).any?
+        end
+
+        def on_rescue(node)
+          return unless style == :semantic
+
+          begin_node, *rescue_nodes, _else_node = *node
+          check_scope(:raise, begin_node)
+
+          rescue_nodes.each do |rescue_node|
+            check_scope(:fail, rescue_node)
+            allow(:raise, rescue_node)
+          end
+        end
+
+        def on_send(node)
+          case style
+          when :semantic
+            check_send(:raise, node) unless ignored_node?(node)
+          when :only_raise
+            return if @custom_fail_defined
+
+            check_send(:fail, node)
+          when :only_fail
+            check_send(:raise, node)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            name =
+              case style
+              when :semantic
+                command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
+              when :only_raise then 'raise'
+              when :only_fail then 'fail'
+              end
+
+            corrector.replace(node.loc.selector, name)
+          end
+        end
+
+        private
+
+        def message(method_name)
+          case style
+          when :semantic
+            method_name == :fail ? RAISE_MSG : FAIL_MSG
+          when :only_raise
+            'Always use `raise` to signal exceptions.'
+          when :only_fail
+            'Always use `fail` to signal exceptions.'
+          end
+        end
+
+        def check_scope(method_name, node)
+          return unless node
+
+          each_command_or_kernel_call(method_name, node) do |send_node|
+            next if ignored_node?(send_node)
+
+            add_offense(send_node,
+                        location: :selector, message: message(method_name))
+            ignore_node(send_node)
+          end
+        end
+
+        def check_send(method_name, node)
+          return unless node && command_or_kernel_call?(method_name, node)
+
+          add_offense(node, location: :selector, message: message(method_name))
+        end
+
+        def command_or_kernel_call?(name, node)
+          node.command?(name) || kernel_call?(node, name)
+        end
+
+        def allow(method_name, node)
+          each_command_or_kernel_call(method_name, node) do |send_node|
+            ignore_node(send_node)
+          end
+        end
+
+        def each_command_or_kernel_call(method_name, node)
+          on_node(:send, node, :rescue) do |send_node|
+            yield send_node if command_or_kernel_call?(method_name, send_node)
+          end
+        end
+      end
+    end
+  end
+end