rubbycop 0.49.0

data/lib/rubbycop/cop/offense.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    # An offense represents a style violation detected by RubbyCop.
+    class Offense
+      include Comparable
+
+      # @api private
+      COMPARISON_ATTRIBUTES = %i[line column cop_name
+                                 message severity].freeze
+
+      # @api public
+      #
+      # @!attribute [r] severity
+      #
+      # @return [RubbyCop::Cop::Severity]
+      attr_reader :severity
+
+      # @api public
+      #
+      # @!attribute [r] location
+      #
+      # @return [Parser::Source::Range]
+      #   the location where the violation is detected.
+      #
+      # @see http://rubydoc.info/github/whitequark/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 = RubbyCop::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.
+      def corrected
+        @status == :unsupported ? false : @status == :corrected
+      end
+      alias corrected? corrected
+
+      # @api public
+      #
+      # @!attribute [r] disabled?
+      #
+      # @return [Boolean]
+      #   whether this offense was locally disabled where it occurred
+      def disabled?
+        @status == :disabled
+      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('%s:%3d:%3d: %s',
+               severity.code, line, real_column, 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 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

data/lib/rubbycop/cop/performance/caller.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Performance
+      # This cop identifies places where `caller[n]`
+      # can be replaced by `caller(n..n).first`.
+      #
+      # @example
+      #   # bad
+      #   caller[n]
+      #   caller.first
+      #
+      #   # good
+      #   caller(n..n).first
+      #   caller(1..1).first
+      class Caller < Cop
+        MSG = 'Use `caller(n..n)` instead of `caller[n]`.'.freeze
+        SCOPE_METHODS = %i[first []].freeze
+
+        def_node_matcher :caller_with_scope_method?, <<-PATTERN
+          (send (send nil :caller ...) ${#{SCOPE_METHODS.map(&:inspect).join(' ')}} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless caller_with_scope_method?(node) && slow_caller?(node)
+          add_offense(node, :selector)
+        end
+
+        private
+
+        def slow_caller?(node)
+          arguments = node.receiver.arguments
+
+          arguments.empty? ||
+            (arguments.length == 1 && arguments[0].int_type?)
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/performance/case_when_splat.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Performance
+      # Place `when` conditions that use splat at the end
+      # of the list of `when` branches.
+      #
+      # Ruby has to allocate memory for the splat expansion every time
+      # that the `case` `when` statement is run. Since Ruby does not support
+      # fall through inside of `case` `when`, like some other languages do,
+      # the order of the `when` branches does not matter. By placing any
+      # splat expansions at the end of the list of `when` branches we will
+      # reduce the number of times that memory has to be allocated for
+      # the expansion.
+      #
+      # This is not a guaranteed performance improvement. If the data being
+      # processed by the `case` condition is normalized in a manner that favors
+      # hitting a condition in the splat expansion, it is possible that
+      # moving the splat condition to the end will use more memory,
+      # and run slightly slower.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when *condition
+      #     bar
+      #   when baz
+      #     foobar
+      #   end
+      #
+      #   case foo
+      #   when *[1, 2, 3, 4]
+      #     bar
+      #   when 5
+      #     baz
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when baz
+      #     foobar
+      #   when *condition
+      #     bar
+      #   end
+      #
+      #   case foo
+      #   when 1, 2, 3, 4
+      #     bar
+      #   when 5
+      #     baz
+      #   end
+      class CaseWhenSplat < Cop
+        include AutocorrectAlignment
+
+        MSG = 'Place `when` conditions with a splat ' \
+              'at the end of the `when` branches.'.freeze
+        ARRAY_MSG = 'Do not expand array literals in `when` conditions.'.freeze
+        PERCENT_W = '%w'.freeze
+        PERCENT_CAPITAL_W = '%W'.freeze
+        PERCENT_I = '%i'.freeze
+        PERCENT_CAPITAL_I = '%I'.freeze
+
+        def on_case(case_node)
+          when_conditions = case_node.when_branches.flat_map(&:conditions)
+
+          splat_offenses(when_conditions).reverse_each do |condition|
+            range = condition.parent.loc.keyword.join(condition.source_range)
+            variable, = *condition
+            message = variable.array_type? ? ARRAY_MSG : MSG
+            add_offense(condition.parent, range, message)
+          end
+        end
+
+        private
+
+        def autocorrect(when_node)
+          lambda do |corrector|
+            if needs_reorder?(when_node)
+              reorder_condition(corrector, when_node)
+            else
+              inline_fix_branch(corrector, when_node)
+            end
+          end
+        end
+
+        def replacement(conditions)
+          reordered = conditions.partition(&:splat_type?).reverse
+          reordered.flatten.map(&:source).join(', ')
+        end
+
+        def inline_fix_branch(corrector, when_node)
+          conditions = when_node.conditions
+          range = range_between(conditions[0].loc.expression.begin_pos,
+                                conditions[-1].loc.expression.end_pos)
+
+          corrector.replace(range, replacement(conditions))
+        end
+
+        def reorder_condition(corrector, when_node)
+          when_branches = when_node.parent.when_branches
+
+          return if when_branches.one?
+
+          corrector.remove(when_branch_range(when_node))
+          corrector.insert_after(when_branches.last.source_range,
+                                 reordering_correction(when_node))
+        end
+
+        def reordering_correction(when_node)
+          new_condition = replacement(when_node.conditions)
+
+          if same_line?(when_node, when_node.body)
+            new_condition_with_then(when_node, new_condition)
+          else
+            new_branch_without_then(when_node, new_condition)
+          end
+        end
+
+        def when_branch_range(when_node)
+          next_branch =
+            when_node.parent.when_branches[when_node.branch_index + 1]
+
+          range_between(when_node.source_range.begin_pos,
+                        next_branch.source_range.begin_pos)
+        end
+
+        def new_condition_with_then(node, new_condition)
+          "\n#{indent_for(node)}when " \
+          "#{new_condition} then #{node.body.source}"
+        end
+
+        def new_branch_without_then(node, new_condition)
+          "\n#{indent_for(node)}when #{new_condition}" \
+          "\n#{indent_for(node.body)}#{node.body.source}"
+        end
+
+        def indent_for(node)
+          ' ' * node.loc.column
+        end
+
+        def splat_offenses(when_conditions)
+          found_non_splat = false
+
+          offenses = when_conditions.reverse.map do |condition|
+            found_non_splat ||= non_splat?(condition)
+
+            next if non_splat?(condition)
+
+            condition if found_non_splat
+          end
+
+          offenses.compact
+        end
+
+        def non_splat?(condition)
+          variable, = *condition
+
+          (condition.splat_type? && variable.array_type?) ||
+            !condition.splat_type?
+        end
+
+        def needs_reorder?(when_node)
+          following_branches =
+            when_node.parent.when_branches[(when_node.branch_index + 1)..-1]
+
+          following_branches.any? do |when_branch|
+            when_branch.conditions.any? do |condition|
+              non_splat?(condition)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/performance/casecmp.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Performance
+      # This cop identifies places where a case-insensitive string comparison
+      # can better be implemented using `casecmp`.
+      #
+      # @example
+      #   @bad
+      #   str.downcase == 'abc'
+      #   str.upcase.eql? 'ABC'
+      #   'abc' == str.downcase
+      #   'ABC'.eql? str.upcase
+      #   str.downcase == str.downcase
+      #
+      #   @good
+      #   str.casecmp('ABC').zero?
+      #   'abc'.casecmp(str).zero?
+      class Casecmp < Cop
+        MSG = 'Use `casecmp` instead of `%s %s`.'.freeze
+        CASE_METHODS = %i[downcase upcase].freeze
+
+        def_node_matcher :downcase_eq, <<-END
+          (send
+            $(send _ ${:downcase :upcase})
+            ${:== :eql? :!=}
+            ${str (send _ {:downcase :upcase} ...) (begin str)})
+        END
+
+        def_node_matcher :eq_downcase, <<-END
+          (send
+            {str (send _ {:downcase :upcase} ...) (begin str)}
+            ${:== :eql? :!=}
+            $(send _ ${:downcase :upcase}))
+        END
+
+        def on_send(node)
+          return if part_of_ignored_node?(node)
+
+          inefficient_comparison(node) do |range, is_other_part, *methods|
+            ignore_node(node) if is_other_part
+            add_offense(node, range, format(MSG, *methods))
+          end
+        end
+
+        def autocorrect(node)
+          downcase_eq(node) do
+            receiver, method, arg = *node
+            variable, = *receiver
+            return correction(node, receiver, method, arg, variable)
+          end
+
+          eq_downcase(node) do
+            arg, method, receiver = *node
+            variable, = *receiver
+            return correction(node, receiver, method, arg, variable)
+          end
+        end
+
+        private
+
+        def inefficient_comparison(node)
+          loc = node.loc
+
+          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
+            *_, method = *other
+            range, is_other_part = downcase_eq_range(method, loc, send_downcase)
+
+            yield range, is_other_part, case_method, eq_method
+            return
+          end
+
+          eq_downcase(node) do |eq_method, send_downcase, case_method|
+            range = loc.selector.join(send_downcase.loc.selector)
+            yield range, false, eq_method, case_method
+          end
+        end
+
+        def downcase_eq_range(method, loc, send_downcase)
+          if CASE_METHODS.include?(method)
+            [loc.expression, true]
+          else
+            [loc.selector.join(send_downcase.loc.selector), false]
+          end
+        end
+
+        def correction(node, _receiver, method, arg, variable)
+          lambda do |corrector|
+            corrector.insert_before(node.loc.expression, '!') if method == :!=
+
+            # we want resulting call to be parenthesized
+            # if arg already includes one or more sets of parens, don't add more
+            # or if method call already used parens, again, don't add more
+            replacement = if arg.send_type? || !parentheses?(arg)
+                            "#{variable.source}.casecmp(#{arg.source}).zero?"
+                          else
+                            "#{variable.source}.casecmp#{arg.source}.zero?"
+                          end
+
+            corrector.replace(node.loc.expression, replacement)
+          end
+        end
+      end
+    end
+  end
+end