rubocop 0.56.0 → 0.57.0

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

@@ -47,7 +47,7 @@ module RuboCop
         private
 
         def check(node)
-          return if node.loc.respond_to?(:heredoc_body)
+          return if node.heredoc?
           return unless node.loc.respond_to?(:begin)
           return unless node.loc.begin
 

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

@@ -82,7 +82,7 @@ module RuboCop
         MSG_USE_PERCENT_X = 'Use `%x` around command string.'.freeze
 
         def on_xstr(node)
-          return if heredoc_literal?(node)
+          return if node.heredoc?
 
           if backtick_literal?(node)
             check_backtick_literal(node)
@@ -161,10 +161,6 @@ module RuboCop
           loc.expression.source[loc.begin.length...-loc.end.length]
         end
 
-        def heredoc_literal?(node)
-          node.loc.respond_to?(:heredoc_body)
-        end
-
         def backtick_literal?(node)
           node.loc.begin.source == '`'
         end

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

@@ -139,14 +139,37 @@ module RuboCop
         def insert_comment(corrector)
           last_special_comment = last_special_comment(processed_source)
           if last_special_comment.nil?
-            corrector.insert_before(processed_source.tokens[0].pos,
-                                    "#{FROZEN_STRING_LITERAL_ENABLED}\n\n")
-          elsif processed_source.following_line(last_special_comment).empty?
-            corrector.insert_after(last_special_comment.pos,
-                                   "\n#{FROZEN_STRING_LITERAL_ENABLED}")
+            corrector.insert_before(correction_range, preceding_comment)
           else
-            corrector.insert_after(last_special_comment.pos,
-                                   "\n#{FROZEN_STRING_LITERAL_ENABLED}\n")
+            corrector.insert_after(correction_range, proceeding_comment)
+          end
+        end
+
+        def preceding_comment
+          if processed_source.tokens[0].space_before?
+            "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+          else
+            "#{FROZEN_STRING_LITERAL_ENABLED}\n\n"
+          end
+        end
+
+        def proceeding_comment
+          last_special_comment = last_special_comment(processed_source)
+          if processed_source.following_line(last_special_comment).empty?
+            "\n#{FROZEN_STRING_LITERAL_ENABLED}"
+          else
+            "\n#{FROZEN_STRING_LITERAL_ENABLED}\n"
+          end
+        end
+
+        def correction_range
+          last_special_comment = last_special_comment(processed_source)
+
+          if last_special_comment.nil?
+            range_with_surrounding_space(range: processed_source.tokens[0],
+                                         side: :left)
+          else
+            last_special_comment.pos
           end
         end
       end

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

@@ -36,12 +36,17 @@ module RuboCop
         MIXIN_METHODS = %i[extend include prepend].freeze
         MSG = 'Put `%<mixin>s` mixins in %<suffix>s.'.freeze
 
-        def on_send(node)
-          return unless node.macro? && MIXIN_METHODS.include?(node.method_name)
+        def on_class(node)
+          begin_node = node.child_nodes.find(&:begin_type?) || node
+          begin_node.each_child_node(:send).select(&:macro?).each do |macro|
+            next unless MIXIN_METHODS.include?(macro.method_name)
 
-          check(node)
+            check(macro)
+          end
         end
 
+        alias on_module on_class
+
         def autocorrect(node)
           range = node.loc.expression
           if separated_style?

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

@@ -222,7 +222,7 @@ module RuboCop
 
         def heredoc_lines(node)
           node.each_node(:dstr)
-              .select { |n| n.loc.respond_to?(:heredoc_body) }
+              .select(&:heredoc?)
               .map { |n| n.loc.heredoc_body }
               .flat_map { |b| (b.line...b.last_line).to_a }
         end

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

@@ -6,10 +6,33 @@ module RuboCop
       # This cop checks for octal, hex, binary and decimal literals using
       # uppercase prefixes and corrects them to lowercase prefix
       # or no prefix (in case of decimals).
-      # eg. for octal use `0o` instead of `0` or `0O`.
       #
-      # Can be configured to use `0` only for octal literals using
-      # `EnforcedOctalStyle` => `zero_only`
+      # @example EnforcedOctalStyle: zero_with_o (default)
+      #   # bad - missing octal prefix
+      #   num = 01234
+      #
+      #   # bad - uppercase prefix
+      #   num = 0O1234
+      #   num = 0X12AB
+      #   num = 0B10101
+      #
+      #   # bad - redundant decimal prefix
+      #   num = 0D1234
+      #   num = 0d1234
+      #
+      #   # good
+      #   num = 0o1234
+      #   num = 0x12AB
+      #   num = 0b10101
+      #   num = 1234
+      #
+      # @example EnforcedOctalStyle: zero_only
+      #   # bad
+      #   num = 0o1234
+      #   num = 0O1234
+      #
+      #   # good
+      #   num = 01234
       class NumericLiteralPrefix < Cop
         include IntegerNode
 

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

@@ -35,7 +35,7 @@ module RuboCop
             block_method_name = resolve_block_method_name(send_or_super)
 
             # TODO: Rails-specific handling that we should probably make
-            # configurable - https://github.com/bbatsov/rubocop/issues/1485
+            # configurable - https://github.com/rubocop-hq/rubocop/issues/1485
             # we should ignore lambdas & procs
             return if proc_node?(send_or_super)
             return if %i[lambda proc].include?(block_method_name)

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unnecessary conditional expressions.
+      #
+      # @example
+      #   # bad
+      #   a = b ? b : c
+      #
+      #   # good
+      #   a = b || c
+      #
+      # @example
+      #   # bad
+      #   if b
+      #     b
+      #   else
+      #     c
+      #   end
+      #
+      #   # good
+      #   b || c
+      class UnneededCondition < Cop
+        include RangeHelp
+
+        MSG = 'Use double pipes `||` instead.'.freeze
+
+        def on_if(node)
+          return unless offense?(node)
+          add_offense(node, location: range_of_offense(node))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.ternary?
+              corrector.replace(range_of_offense(node), '||')
+            else
+              corrected = [node.if_branch.source,
+                           else_source(node.else_branch)].join(' || ')
+
+              corrector.replace(node.source_range, corrected)
+            end
+          end
+        end
+
+        private
+
+        def range_of_offense(node)
+          return :expression unless node.ternary?
+          range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
+        end
+
+        def offense?(node)
+          condition, if_branch, else_branch = *node
+
+          condition == if_branch && !node.elsif? && (
+            node.ternary? ||
+            !else_branch.instance_of?(AST::Node) ||
+            else_branch.single_line?
+          )
+        end
+
+        def else_source(else_branch)
+          wrap_else = MODIFIER_NODES.include?(else_branch.type) &&
+                      else_branch.modifier_form?
+          wrap_else ? "(#{else_branch.source})" : else_branch.source
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,19 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for usage of the %q/%Q syntax when '' or "" would do.
+      #
+      # @example
+      #
+      #   # bad
+      #   name = %q(Bruce Wayne)
+      #   time = %q(8 o'clock)
+      #   question = %q("What did you say?")
+      #
+      #   # good
+      #   name = 'Bruce Wayne'
+      #   time = "8 o'clock"
+      #   question = '"What did you say?"'
+      #
       class UnneededPercentQ < Cop
         MSG = 'Use `%<q_type>s` only for strings that contain both ' \
               'single quotes and double quotes%<extra>s.'.freeze

data/lib/rubocop/cop/variable_force.rb

@@ -82,10 +82,9 @@ module RuboCop
       end
 
       def process_node(node)
-        catch(:skip_children) do
-          dispatch_node(node)
-          process_children(node)
-        end
+        method_name = node_handler_method_name(node)
+        retval = send(method_name, node) if method_name
+        process_children(node) unless retval == :skip_children
       end
 
       private
@@ -105,34 +104,34 @@ module RuboCop
       end
 
       def skip_children!
-        throw :skip_children
+        :skip_children
       end
 
       # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-      def dispatch_node(node)
+      def node_handler_method_name(node)
         case node.type
         when VARIABLE_ASSIGNMENT_TYPE
-          process_variable_assignment(node)
+          :process_variable_assignment
         when REGEXP_NAMED_CAPTURE_TYPE
-          process_regexp_named_captures(node)
+          :process_regexp_named_captures
         when MULTIPLE_ASSIGNMENT_TYPE
-          process_variable_multiple_assignment(node)
+          :process_variable_multiple_assignment
         when VARIABLE_REFERENCE_TYPE
-          process_variable_referencing(node)
+          :process_variable_referencing
         when RESCUE_TYPE
-          process_rescue(node)
+          :process_rescue
         when ZERO_ARITY_SUPER_TYPE
-          process_zero_arity_super(node)
+          :process_zero_arity_super
         when SEND_TYPE
-          process_send(node)
+          :process_send
         when *ARGUMENT_DECLARATION_TYPES
-          process_variable_declaration(node)
+          :process_variable_declaration
         when *OPERATOR_ASSIGNMENT_TYPES
-          process_variable_operator_assignment(node)
+          :process_variable_operator_assignment
         when *LOOP_TYPES
-          process_loop(node)
+          :process_loop
         when *SCOPE_TYPES
-          process_scope(node)
+          :process_scope
         end
       end
       # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity

data/lib/rubocop/options.rb

@@ -65,6 +65,7 @@ module RuboCop
         add_severity_option(opts)
         add_flags_with_optional_args(opts)
         add_boolean_flags(opts)
+        add_aliases(opts)
 
         option(opts, '-s', '--stdin FILE')
       end
@@ -142,7 +143,7 @@ module RuboCop
       end
     end
 
-    def add_boolean_flags(opts) # rubocop:disable Metrics/MethodLength
+    def add_boolean_flags(opts)
       option(opts, '-F', '--fail-fast')
       option(opts, '-C', '--cache FLAG')
       option(opts, '-d', '--debug')
@@ -150,10 +151,6 @@ module RuboCop
       option(opts, '-E', '--extra-details')
       option(opts, '-S', '--display-style-guide')
       option(opts, '-R', '--rails')
-      option(opts, '-l', '--lint') do
-        @options[:only] ||= []
-        @options[:only] << 'Lint'
-      end
       option(opts, '-a', '--auto-correct')
 
       option(opts, '--[no-]color')
@@ -163,6 +160,18 @@ module RuboCop
       option(opts, '-P', '--parallel')
     end
 
+    def add_aliases(opts)
+      option(opts, '-l', '--lint') do
+        @options[:only] ||= []
+        @options[:only] << 'Lint'
+      end
+      option(opts, '-x', '--fix-layout') do
+        @options[:only] ||= []
+        @options[:only] << 'Layout'
+        @options[:auto_correct] = true
+      end
+    end
+
     def add_list_options(opts)
       option(opts, '-L', '--list-target-files')
     end
@@ -379,6 +388,7 @@ module RuboCop
       lint:                  'Run only lint cops.',
       list_target_files:     'List all files RuboCop will inspect.',
       auto_correct:          'Auto-correct offenses.',
+      fix_layout:            'Run only layout cops, with auto-correct on.',
       color:                 'Force color output on or off.',
       version:               'Display version.',
       verbose_version:       'Display verbose version.',

data/lib/rubocop/result_cache.rb

@@ -155,12 +155,12 @@ module RuboCop
       ResultCache.source_checksum ||=
         begin
           lib_root = File.join(File.dirname(__FILE__), '..')
-          bin_root = File.join(lib_root, '..', 'bin')
+          exe_root = File.join(lib_root, '..', 'exe')
 
           # These are all the files we have `require`d plus everything in the
-          # bin directory. A change to any of them could affect the cop output
+          # exe directory. A change to any of them could affect the cop output
           # so we include them in the cache hash.
-          source_files = $LOADED_FEATURES + Find.find(bin_root).to_a
+          source_files = $LOADED_FEATURES + Find.find(exe_root).to_a
           sources = source_files
                     .select { |path| File.file?(path) }
                     .sort

data/lib/rubocop/string_util.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'jaro_winkler'
+
 module RuboCop
   # This module provides approximate string matching methods.
   module StringUtil
@@ -8,152 +10,5 @@ module RuboCop
     def similarity(string_a, string_b)
       JaroWinkler.distance(string_a.to_s, string_b.to_s)
     end
-
-    # This class computes Jaro distance, which is a measure of similarity
-    # between two strings.
-    class Jaro
-      attr_reader :shorter, :longer
-
-      def self.distance(*args)
-        new(*args).distance
-      end
-
-      def initialize(string_a, string_b)
-        if string_a.size < string_b.size
-          @shorter = string_a
-          @longer = string_b
-        else
-          @shorter = string_b
-          @longer = string_a
-        end
-      end
-
-      def distance
-        @distance ||= compute_distance
-      end
-
-      private
-
-      def compute_distance
-        common_chars_a, common_chars_b = find_common_characters
-        matched_count = common_chars_a.size
-
-        return 0.0 if matched_count.zero?
-
-        transposition_count =
-          count_transpositions(common_chars_a, common_chars_b)
-
-        compute_non_zero_distance(matched_count.to_f, transposition_count)
-      end
-
-      # rubocop:disable Metrics/AbcSize
-      def find_common_characters
-        common_chars_of_shorter = Array.new(shorter.size)
-        common_chars_of_longer = Array.new(longer.size)
-
-        shorter.each_char.with_index do |shorter_char, shorter_index|
-          matching_index_range(shorter_index).each do |longer_index|
-            longer_char = longer.chars[longer_index]
-
-            next unless shorter_char == longer_char
-
-            common_chars_of_shorter[shorter_index] = shorter_char
-            common_chars_of_longer[longer_index] = longer_char
-
-            # Mark the matching character as already used
-            longer.chars[longer_index] = nil
-
-            break
-          end
-        end
-
-        [common_chars_of_shorter, common_chars_of_longer].map(&:compact)
-      end
-      # rubocop:enable Metrics/AbcSize
-
-      def count_transpositions(common_chars_a, common_chars_b)
-        common_chars_a.size.times.count do |index|
-          common_chars_a[index] != common_chars_b[index]
-        end
-      end
-
-      def compute_non_zero_distance(matched_count, transposition_count)
-        sum = (matched_count / shorter.size.to_f) +
-              (matched_count / longer.size.to_f) +
-              ((matched_count - transposition_count / 2) / matched_count)
-
-        sum / 3.0
-      end
-
-      def matching_index_range(origin)
-        min = origin - matching_window
-        min = 0 if min < 0
-
-        max = origin + matching_window
-
-        min..max
-      end
-
-      def matching_window
-        @matching_window ||= (longer.size / 2) - 1
-      end
-    end
-
-    # This class computes Jaro-Winkler distance, which adds prefix-matching
-    # bonus to Jaro distance.
-    class JaroWinkler < Jaro
-      # Add the prefix bonus only when the Jaro distance is above this value.
-      # In other words, if the Jaro distance is less than this value,
-      # JaroWinkler.distance returns the raw Jaro distance.
-      DEFAULT_BOOST_THRESHOLD = 0.7
-
-      # How much the prefix bonus is weighted.
-      # This should not exceed 0.25.
-      DEFAULT_SCALING_FACTOR = 0.1
-
-      # Cutoff the common prefix length to this value if it's longer than this.
-      MAX_COMMON_PREFIX_LENGTH = 4
-
-      attr_reader :boost_threshold, :scaling_factor
-
-      def initialize(string_a, string_b,
-                     boost_threshold = nil, scaling_factor = nil)
-        super(string_a, string_b)
-        @boost_threshold = boost_threshold || DEFAULT_BOOST_THRESHOLD
-        @scaling_factor = scaling_factor || DEFAULT_SCALING_FACTOR
-      end
-
-      private
-
-      def compute_distance
-        jaro_distance = super
-
-        if jaro_distance >= boost_threshold
-          bonus = limited_common_prefix_length.to_f * scaling_factor.to_f *
-                  (1.0 - jaro_distance)
-          jaro_distance + bonus
-        else
-          jaro_distance
-        end
-      end
-
-      def limited_common_prefix_length
-        length = common_prefix_length
-
-        if length > MAX_COMMON_PREFIX_LENGTH
-          MAX_COMMON_PREFIX_LENGTH
-        else
-          length
-        end
-      end
-
-      def common_prefix_length
-        shorter.size.times do |index|
-          return index unless shorter[index] == longer[index]
-        end
-
-        shorter.size
-      end
-    end
   end
 end