rubocop 0.75.1

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for while and until statements that would fit on one line
+      # if written as a modifier while/until. The maximum line length is
+      # configured in the `Metrics/LineLength` cop.
+      #
+      # @example
+      #   # bad
+      #   while x < 10
+      #     x += 1
+      #   end
+      #
+      #   # good
+      #   x += 1 while x < 10
+      #
+      # @example
+      #   # bad
+      #   until x > 10
+      #     x += 1
+      #   end
+      #
+      #   # good
+      #   x += 1 until x > 10
+      class WhileUntilModifier < Cop
+        include StatementModifier
+
+        MSG = 'Favor modifier `%<keyword>s` usage when ' \
+              'having a single-line body.'
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        def autocorrect(node)
+          oneline = "#{node.body.source} #{node.keyword} " \
+                    "#{node.condition.source}"
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, oneline)
+          end
+        end
+
+        private
+
+        def check(node)
+          return unless node.multiline? && single_line_as_modifier?(node)
+
+          add_offense(node, location: :keyword,
+                            message: format(MSG, keyword: node.keyword))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop can check for array literals made up of word-like
+      # strings, that are not using the %w() syntax.
+      #
+      # Alternatively, it can check for uses of the %w() syntax, in projects
+      # which do not want to include that syntax.
+      #
+      # Configuration option: MinSize
+      # If set, arrays with fewer elements than this value will not trigger the
+      # cop. For example, a `MinSize` of `3` will not enforce a style on an
+      # array of 2 or fewer elements.
+      #
+      # @example EnforcedStyle: percent (default)
+      #   # good
+      #   %w[foo bar baz]
+      #
+      #   # bad
+      #   ['foo', 'bar', 'baz']
+      #
+      # @example EnforcedStyle: brackets
+      #   # good
+      #   ['foo', 'bar', 'baz']
+      #
+      #   # bad
+      #   %w[foo bar baz]
+      class WordArray < Cop
+        include ArrayMinSize
+        include ArraySyntax
+        include ConfigurableEnforcedStyle
+        include PercentArray
+
+        PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
+        ARRAY_MSG = 'Use `[]` for an array of words.'
+
+        class << self
+          attr_accessor :largest_brackets
+        end
+
+        def on_array(node)
+          if bracketed_array_of?(:str, node)
+            return if complex_content?(node.values)
+
+            check_bracketed_array(node)
+          elsif node.percent_literal?(:string)
+            check_percent_array(node)
+          end
+        end
+
+        def autocorrect(node)
+          if style == :percent
+            PercentLiteralCorrector
+              .new(@config, @preferred_delimiters)
+              .correct(node, 'w')
+          else
+            correct_bracketed(node)
+          end
+        end
+
+        private
+
+        def check_bracketed_array(node)
+          return if allowed_bracket_array?(node)
+
+          array_style_detected(:brackets, node.values.size)
+          add_offense(node) if style == :percent
+        end
+
+        def complex_content?(strings)
+          strings.any? do |s|
+            string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
+            !string.valid_encoding? ||
+              string !~ word_regex || string =~ / /
+          end
+        end
+
+        def word_regex
+          Regexp.new(cop_config['WordRegex'])
+        end
+
+        def correct_bracketed(node)
+          words = node.children.map do |word|
+            if word.dstr_type?
+              string_literal = to_string_literal(word.source)
+
+              trim_string_interporation_escape_character(string_literal)
+            else
+              to_string_literal(word.children[0])
+            end
+          end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, "[#{words.join(', ')}]")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop can either enforce or forbid Yoda conditions,
+      # i.e. comparison operations where the order of expression is reversed.
+      # eg. `5 == x`
+      #
+      # @example EnforcedStyle: forbid_for_all_comparison_operators (default)
+      #   # bad
+      #   99 == foo
+      #   "bar" != foo
+      #   42 >= foo
+      #   10 < bar
+      #
+      #   # good
+      #   foo == 99
+      #   foo == "bar"
+      #   foo <= 42
+      #   bar > 10
+      #
+      # @example EnforcedStyle: forbid_for_equality_operators_only
+      #   # bad
+      #   99 == foo
+      #   "bar" != foo
+      #
+      #   # good
+      #   99 >= foo
+      #   3 < a && a < 5
+      #
+      # @example EnforcedStyle: require_for_all_comparison_operators
+      #   # bad
+      #   foo == 99
+      #   foo == "bar"
+      #   foo <= 42
+      #   bar > 10
+      #
+      #   # good
+      #   99 == foo
+      #   "bar" != foo
+      #   42 >= foo
+      #   10 < bar
+      #
+      # @example EnforcedStyle: require_for_equality_operators_only
+      #   # bad
+      #   99 >= foo
+      #   3 < a && a < 5
+      #
+      #   # good
+      #   99 == foo
+      #   "bar" != foo
+      class YodaCondition < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = 'Reverse the order of the operands `%<source>s`.'
+
+        REVERSE_COMPARISON = {
+          '<' => '>',
+          '<=' => '>=',
+          '>' => '<',
+          '>=' => '<='
+        }.freeze
+
+        EQUALITY_OPERATORS = %i[== !=].freeze
+
+        NONCOMMUTATIVE_OPERATORS = %i[===].freeze
+
+        def on_send(node)
+          return unless yoda_compatible_condition?(node)
+          return if equality_only? && non_equality_operator?(node)
+
+          valid_yoda?(node) || add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(actual_code_range(node), corrected_code(node))
+          end
+        end
+
+        private
+
+        def enforce_yoda?
+          style == :require_for_all_comparison_operators ||
+            style == :require_for_equality_operators_only
+        end
+
+        def equality_only?
+          style == :forbid_for_equality_operators_only ||
+            style == :require_for_equality_operators_only
+        end
+
+        def yoda_compatible_condition?(node)
+          node.comparison_method? &&
+            !noncommutative_operator?(node)
+        end
+
+        def valid_yoda?(node)
+          lhs = node.receiver
+          rhs = node.first_argument
+
+          return true if lhs.literal? && rhs.literal? ||
+                         !lhs.literal? && !rhs.literal?
+
+          enforce_yoda? ? lhs.literal? : rhs.literal?
+        end
+
+        def message(node)
+          format(MSG, source: node.source)
+        end
+
+        def corrected_code(node)
+          lhs = node.receiver
+          rhs = node.first_argument
+
+          "#{rhs.source} #{reverse_comparison(node.method_name)} #{lhs.source}"
+        end
+
+        def actual_code_range(node)
+          range_between(
+            node.loc.expression.begin_pos, node.loc.expression.end_pos
+          )
+        end
+
+        def reverse_comparison(operator)
+          REVERSE_COMPARISON.fetch(operator.to_s, operator)
+        end
+
+        def non_equality_operator?(node)
+          !EQUALITY_OPERATORS.include?(node.method_name)
+        end
+
+        def noncommutative_operator?(node)
+          NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for numeric comparisons that can be replaced
+      # by a predicate method, such as receiver.length == 0,
+      # receiver.length > 0, receiver.length != 0,
+      # receiver.length < 1 and receiver.size == 0 that can be
+      # replaced by receiver.empty? and !receiver.empty?.
+      #
+      # @example
+      #   # bad
+      #   [1, 2, 3].length == 0
+      #   0 == "foobar".length
+      #   array.length < 1
+      #   {a: 1, b: 2}.length != 0
+      #   string.length > 0
+      #   hash.size > 0
+      #
+      #   # good
+      #   [1, 2, 3].empty?
+      #   "foobar".empty?
+      #   array.empty?
+      #   !{a: 1, b: 2}.empty?
+      #   !string.empty?
+      #   !hash.empty?
+      class ZeroLengthPredicate < Cop
+        ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
+        NONZERO_MSG = 'Use `!empty?` instead of ' \
+                      '`%<lhs>s %<opr>s %<rhs>s`.'
+
+        def on_send(node)
+          check_zero_length_predicate(node)
+          check_nonzero_length_predicate(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement(node))
+          end
+        end
+
+        private
+
+        def check_zero_length_predicate(node)
+          zero_length_predicate = zero_length_predicate(node)
+
+          return unless zero_length_predicate
+
+          lhs, opr, rhs = zero_length_predicate
+
+          return if non_polymorphic_collection?(node)
+
+          add_offense(
+            node,
+            message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          )
+        end
+
+        def check_nonzero_length_predicate(node)
+          nonzero_length_predicate = nonzero_length_predicate(node)
+
+          return unless nonzero_length_predicate
+
+          lhs, opr, rhs = nonzero_length_predicate
+
+          return if non_polymorphic_collection?(node)
+
+          add_offense(
+            node,
+            message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
+          )
+        end
+
+        def_node_matcher :zero_length_predicate, <<~PATTERN
+          {(send (send (...) ${:length :size}) $:== (int $0))
+           (send (int $0) $:== (send (...) ${:length :size}))
+           (send (send (...) ${:length :size}) $:<  (int $1))
+           (send (int $1) $:> (send (...) ${:length :size}))}
+        PATTERN
+
+        def_node_matcher :nonzero_length_predicate, <<~PATTERN
+          {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
+           (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
+        PATTERN
+
+        def replacement(node)
+          receiver = zero_length_receiver(node)
+          return "#{receiver.source}.empty?" if receiver
+
+          "!#{other_receiver(node).source}.empty?"
+        end
+
+        def_node_matcher :zero_length_receiver, <<~PATTERN
+          {(send (send $_ _) :== (int 0))
+           (send (int 0) :== (send $_ _))
+           (send (send $_ _) :<  (int 1))
+           (send (int 1) :> (send $_ _))}
+        PATTERN
+
+        def_node_matcher :other_receiver, <<~PATTERN
+          {(send (send $_ _) _ _)
+           (send _ _ (send $_ _))}
+        PATTERN
+
+        # Some collection like objects in the Ruby standard library
+        # implement `#size`, but not `#empty`. We ignore those to
+        # reduce false positives.
+        def_node_matcher :non_polymorphic_collection?, <<~PATTERN
+          {(send (send (send (const nil? :File) :stat _) ...) ...)
+           (send (send (send (const nil? {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubocop/cop/team.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # FIXME
+    class Team
+      DEFAULT_OPTIONS = {
+        auto_correct: false,
+        debug: false
+      }.freeze
+
+      Investigation = Struct.new(:offenses, :errors)
+
+      attr_reader :errors, :warnings, :updated_source_file
+
+      alias updated_source_file? updated_source_file
+
+      def initialize(cop_classes, config, options = nil)
+        @cop_classes = cop_classes
+        @config = config
+        @options = options || DEFAULT_OPTIONS
+        @errors = []
+        @warnings = []
+
+        validate_config
+      end
+
+      def autocorrect?
+        @options[:auto_correct]
+      end
+
+      def debug?
+        @options[:debug]
+      end
+
+      def inspect_file(processed_source)
+        # If we got any syntax errors, return only the syntax offenses.
+        unless processed_source.valid_syntax?
+          return Lint::Syntax.offenses_from_processed_source(
+            processed_source, @config, @options
+          )
+        end
+
+        offenses(processed_source)
+      end
+
+      def cops
+        only = @options.fetch(:only, [])
+        safe = @options.fetch(:safe, false)
+        @cops ||= @cop_classes.enabled(@config, only, safe).map do |cop_class|
+          cop_class.new(@config, @options)
+        end
+      end
+
+      def forces
+        @forces ||= forces_for(cops)
+      end
+
+      def forces_for(cops)
+        Force.all.each_with_object([]) do |force_class, forces|
+          joining_cops = cops.select { |cop| cop.join_force?(force_class) }
+          next if joining_cops.empty?
+
+          forces << force_class.new(joining_cops)
+        end
+      end
+
+      def autocorrect(buffer, cops)
+        @updated_source_file = false
+        return unless autocorrect?
+
+        new_source = autocorrect_all_cops(buffer, cops)
+
+        return if new_source == buffer.source
+
+        if @options[:stdin]
+          # holds source read in from stdin, when --stdin option is used
+          @options[:stdin] = new_source
+        else
+          filename = buffer.name
+          File.open(filename, 'w') { |f| f.write(new_source) }
+        end
+        @updated_source_file = true
+      rescue RuboCop::ErrorWithAnalyzedFileLocation => e
+        process_errors(buffer.name, [e])
+        raise e.cause
+      end
+
+      private
+
+      def offenses(processed_source)
+        # The autocorrection process may have to be repeated multiple times
+        # until there are no corrections left to perform
+        # To speed things up, run auto-correcting cops by themselves, and only
+        # run the other cops when no corrections are left
+        autocorrect_cops, other_cops = cops.partition(&:autocorrect?)
+
+        autocorrect =
+          investigate(autocorrect_cops, processed_source) do |offenses|
+            # We corrected some errors. Another round of inspection will be
+            # done, and any other offenses will be caught then, so we don't
+            # need to continue.
+            return offenses if autocorrect(processed_source.buffer,
+                                           autocorrect_cops)
+          end
+
+        other = investigate(other_cops, processed_source)
+
+        errors = [*autocorrect.errors, *other.errors]
+        process_errors(processed_source.path, errors)
+
+        autocorrect.offenses.concat(other.offenses)
+      end
+
+      def investigate(cops, processed_source)
+        return Investigation.new([], {}) if cops.empty?
+
+        commissioner = Commissioner.new(cops, forces_for(cops))
+        offenses = commissioner.investigate(processed_source)
+        yield offenses if block_given?
+
+        Investigation.new(offenses, commissioner.errors)
+      end
+
+      def autocorrect_all_cops(buffer, cops)
+        corrector = Corrector.new(buffer)
+
+        collate_corrections(corrector, cops)
+
+        if !corrector.corrections.empty?
+          corrector.rewrite
+        else
+          buffer.source
+        end
+      end
+
+      def collate_corrections(corrector, cops)
+        skips = Set.new
+
+        cops.each do |cop|
+          next if cop.corrections.empty?
+          next if skips.include?(cop.class)
+
+          corrector.corrections.concat(cop.corrections)
+          skips.merge(cop.class.autocorrect_incompatible_with)
+        end
+      end
+
+      def validate_config
+        cops.each do |cop|
+          cop.validate_config if cop.respond_to?(:validate_config)
+        end
+      end
+
+      def process_errors(file, errors)
+        errors.each do |error|
+          line = ":#{error.line}" if error.line
+          column = ":#{error.column}" if error.column
+          location = "#{file}#{line}#{column}"
+          cause = error.cause
+
+          if cause.is_a?(Warning)
+            handle_warning(cause, location)
+          else
+            handle_error(cause, location, error.cop)
+          end
+        end
+      end
+
+      def handle_warning(error, location)
+        message = Rainbow("#{error.message} (from file: #{location})").yellow
+
+        @warnings << message
+        warn message
+        puts error.backtrace if debug?
+      end
+
+      def handle_error(error, location, cop)
+        message = Rainbow("An error occurred while #{cop.name}" \
+                           " cop was inspecting #{location}.").red
+        @errors << message
+        warn message
+        if debug?
+          puts error.message, error.backtrace
+        else
+          warn 'To see the complete backtrace run rubocop -d.'
+        end
+      end
+    end
+  end
+end