rubocop 0.48.1 → 0.49.0

data/lib/rubocop/cop/lint/duplicate_methods.rb

@@ -143,7 +143,8 @@ module RuboCop
 
         def source_location(node)
           range = node.location.expression
-          "#{range.source_buffer.name}:#{range.line}"
+          path = smart_path(range.source_buffer.name)
+          "#{path}:#{range.line}"
         end
       end
     end

data/lib/rubocop/cop/lint/rescue_type.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Check for arguments to `rescue` that will result in a `TypeError`
+      # if an exception is raised.
+      #
+      # @example
+      #   # bad
+      #   begin
+      #     bar
+      #   rescue nil
+      #     baz
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     bar
+      #   rescue 1, 'a', "#{b}", 0.0, [], {}
+      #     baz
+      #   end
+      #
+      #   # good
+      #   begin
+      #     bar
+      #   rescue
+      #     baz
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     bar
+      #   rescue NameError
+      #     baz
+      #   end
+      class RescueType < Cop
+        include RescueNode
+
+        MSG = 'Rescuing from `%s` will raise a `TypeError` instead of ' \
+              'catching the actual exception.'.freeze
+        INVALID_TYPES = %i[array dstr float hash nil int str sym].freeze
+
+        def on_resbody(node)
+          rescued, _, _body = *node
+          return if rescued.nil?
+          exceptions = *rescued
+          invalid_exceptions = invalid_exceptions(exceptions)
+          return if invalid_exceptions.empty?
+
+          add_offense(node,
+                      node.loc.keyword.join(rescued.loc.expression),
+                      format(MSG, invalid_exceptions.map(&:source).join(', ')))
+        end
+
+        def autocorrect(node)
+          rescued, _, _body = *node
+          exceptions = *rescued
+          valid_exceptions = exceptions - invalid_exceptions(exceptions)
+          correction = valid_exceptions.map(&:source).join(', ')
+          correction = " #{correction}" unless correction.empty?
+          range = Parser::Source::Range.new(node.loc.expression,
+                                            node.loc.keyword.end_pos,
+                                            rescued.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, correction)
+          end
+        end
+
+        private
+
+        def invalid_exceptions(exceptions)
+          exceptions.select do |exception|
+            INVALID_TYPES.include?(exception.type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/script_permission.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks if a file which has a shebang line as
+      # its first line is granted execute permission.
+      class ScriptPermission < Cop
+        MSG = "Script file %s doesn't have execute permission.".freeze
+        SHEBANG = '#!'.freeze
+
+        def investigate(processed_source)
+          return if Platform.windows?
+          return unless start_with_shebang?(processed_source)
+          return if executable?(processed_source)
+          comment = processed_source.comments[0]
+          message = format_message_from(processed_source)
+          add_offense(comment, :expression, message)
+        end
+
+        private
+
+        def start_with_shebang?(processed_source)
+          return false if processed_source[0].nil?
+          processed_source[0].start_with?(SHEBANG)
+        end
+
+        def executable?(processed_source)
+          # Returns true if stat is executable or if the operating system
+          # doesn't distinguish executable files from nonexecutable files.
+          # See at: https://github.com/ruby/ruby/blob/ruby_2_4/file.c#L5362
+          File.stat(processed_source.buffer.name).executable?
+        end
+
+        def format_message_from(processed_source)
+          basename = File.basename(processed_source.buffer.name)
+          format(MSG, basename)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -104,7 +104,7 @@ module RuboCop
         def on_block(node)
           return unless eval_call?(node)
 
-          check_node(node.children[2]) # block body
+          check_node(node.body)
         end
 
         def on_sclass(node)

data/lib/rubocop/cop/message_annotator.rb

@@ -15,6 +15,12 @@ module RuboCop
     class MessageAnnotator
       attr_reader :options, :config, :cop_config
 
+      @style_guide_urls = {}
+
+      class << self
+        attr_reader :style_guide_urls
+      end
+
       # @param config [RuboCop::Config] Check configs for all cops
       #   @note Message Annotator specifically checks the
       #     following config options for_all_cops
@@ -28,14 +34,14 @@ module RuboCop
       # @option cop_config [String] :Reference Full reference URL
       # @option cop_config [String] :Details
       #
-      # @param [Hash, nil] optional options
-      # @option option [Boolean] :display_style_guide
+      # @param [Hash, nil] options optional
+      # @option options [Boolean] :display_style_guide
       #   Include style guide and reference URLs
-      # @option option [Boolean] :extra_details
+      # @option options [Boolean] :extra_details
       #   Include cop specific details
-      # @option option [Boolean] :debug
+      # @option options [Boolean] :debug
       #   Include debug output
-      # @option option [Boolean] :display_cop_names
+      # @option options [Boolean] :display_cop_names
       #   Include cop name
       def initialize(config, cop_config, options)
         @config = config
@@ -49,7 +55,7 @@ module RuboCop
       # @return [String] annotated message
       def annotate(message, name)
         message = "#{name}: #{message}" if display_cop_names?
-        message += " #{details}" if extra_details?
+        message += " #{details}" if extra_details? && details
         if display_style_guide?
           links = urls.join(', ')
           message = "#{message} (#{links})"
@@ -67,16 +73,20 @@ module RuboCop
         url = cop_config['StyleGuide']
         return nil if url.nil? || url.empty?
 
-        base_url = config.for_all_cops['StyleGuideBaseURL']
-        return url if base_url.nil? || base_url.empty?
-
-        URI.join(base_url, url).to_s
+        self.class.style_guide_urls[url] ||= begin
+          base_url = config.for_all_cops['StyleGuideBaseURL']
+          if base_url.nil? || base_url.empty?
+            url
+          else
+            URI.join(base_url, url).to_s
+          end
+        end
       end
 
       def display_style_guide?
-        !urls.empty? &&
-          (options[:display_style_guide] ||
-            config.for_all_cops['DisplayStyleGuide'])
+        (options[:display_style_guide] ||
+         config.for_all_cops['DisplayStyleGuide']) &&
+          !urls.empty?
       end
 
       def reference_url

data/lib/rubocop/cop/metrics/block_length.rb

@@ -13,7 +13,7 @@ module RuboCop
         LABEL = 'Block'.freeze
 
         def on_block(node)
-          return if excluded_methods.include?(node.method_name.to_s)
+          return if excluded_methods.include?(node.send_node.method_name.to_s)
           check_code_length(node)
         end
 

data/lib/rubocop/cop/mixin/array_min_size.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Handles the `MinSize` configuration option for array-based cops
+    # `Style/SymbolArray` and `Style/WordArray`, which check for use of the
+    # relevant percent literal syntax such as `%i[...]` and `%w[...]`
+    module ArrayMinSize
+      private
+
+      def below_array_length?(node)
+        node.values.length < min_size_config
+      end
+
+      def min_size_config
+        cop_config['MinSize']
+      end
+
+      def array_style_detected(style, ary_size)
+        cfg = config_to_allow_offenses
+        return if cfg['Enabled'] == false
+
+        largest_brackets = largest_brackets_size(style, ary_size)
+        smallest_percent = smallest_percent_size(style, ary_size)
+
+        if cfg['EnforcedStyle'] == style.to_s
+          # do nothing
+        elsif cfg['EnforcedStyle'].nil?
+          cfg['EnforcedStyle'] = style.to_s
+        elsif smallest_percent <= largest_brackets
+          self.config_to_allow_offenses = { 'Enabled' => false }
+        else
+          cfg['EnforcedStyle'] = 'percent'
+          cfg['MinSize'] = largest_brackets + 1
+        end
+      end
+
+      def largest_brackets_size(style, ary_size)
+        self.class.largest_brackets ||= -Float::INFINITY
+
+        if style == :brackets && ary_size > self.class.largest_brackets
+          self.class.largest_brackets = ary_size
+        end
+
+        self.class.largest_brackets
+      end
+
+      def smallest_percent_size(style, ary_size)
+        @smallest_percent ||= Float::INFINITY
+
+        if style == :percent && ary_size < @smallest_percent
+          @smallest_percent = ary_size
+        end
+
+        @smallest_percent
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -27,12 +27,17 @@ module RuboCop
         # (if there is more than one which matches the observed code)
         detected_as_strings = Array(detected).map(&:to_s)
 
-        if !detected_style # we haven't observed any specific style yet
-          self.detected_style = detected_as_strings
-        elsif detected_style.is_a?(Array)
-          self.detected_style &= detected_as_strings
-        elsif !detected.include?(detected_style)
+        updated_list = if detected_style
+                         detected_style & detected_as_strings
+                       else
+                         # We haven't observed any specific style yet.
+                         detected_as_strings
+                       end
+        if updated_list.empty?
           no_acceptable_style!
+        else
+          self.detected_style = updated_list
+          config_to_allow_offenses[style_parameter_name] = updated_list.first
         end
       end
 
@@ -42,7 +47,6 @@ module RuboCop
 
       def no_acceptable_style!
         self.config_to_allow_offenses = { 'Enabled' => false }
-        Formatter::DisabledConfigFormatter.detected_styles[cop_name] = []
       end
 
       def detected_style
@@ -51,11 +55,6 @@ module RuboCop
 
       def detected_style=(style)
         Formatter::DisabledConfigFormatter.detected_styles[cop_name] = style
-
-        return no_acceptable_style! if style.nil?
-        return no_acceptable_style! if style.empty?
-
-        config_to_allow_offenses[style_parameter_name] = style.first
       end
 
       alias conflicting_styles_detected no_acceptable_style!

data/lib/rubocop/cop/mixin/def_node.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    # Common functionality for checking if nodes.
+    # Common functionality for checking def nodes.
     module DefNode
       extend NodePattern::Macros
 

data/lib/rubocop/cop/mixin/empty_lines_around_body.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    module Style
+    module Layout
       # Common functionality for checking if presence/absence of empty lines
       # around some kind of body matches the configuration.
       module EmptyLinesAroundBody

data/lib/rubocop/cop/mixin/enforce_superclass.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for enforcing a specific superclass
+    module EnforceSuperclass
+      def self.included(base)
+        base.def_node_matcher :class_definition, <<-PATTERN
+        (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
+        PATTERN
+
+        base.def_node_matcher :class_new_definition, <<-PATTERN
+        [!^(casgn nil :#{base::SUPERCLASS} ...) (send (const nil :Class) :new #{base::BASE_PATTERN})]
+        PATTERN
+      end
+
+      def on_class(node)
+        class_definition(node) do
+          add_offense(node.children[1], :expression, self.class::MSG)
+        end
+      end
+
+      def on_send(node)
+        class_new_definition(node) do
+          add_offense(node.children.last, :expression, self.class::MSG)
+        end
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          corrector.replace(node.source_range, self.class::SUPERCLASS)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/hash_alignment.rb

@@ -2,7 +2,7 @@
 
 module RuboCop
   module Cop
-    # Common funcitonality for checking hash alignment.
+    # Common functionality for checking hash alignment.
     module HashAlignment
       # Handles calculation of deltas when the enforced style is 'key'.
       class KeyAlignment

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -49,7 +49,7 @@ module RuboCop
         if kw_node_with_special_indentation(node)
           # This cop could have its own IndentationWidth configuration
           configured_indentation_width +
-            @config.for_cop('Style/IndentationWidth')['Width']
+            @config.for_cop('Layout/IndentationWidth')['Width']
         else
           configured_indentation_width
         end
@@ -105,7 +105,7 @@ module RuboCop
         end
       end
 
-      def argument_in_method_call(node)
+      def argument_in_method_call(node, kind)
         node.each_ancestor(:send, :block).find do |a|
           # If the node is inside a block, it makes no difference if that block
           # is an argument in a method call. It doesn't count.
@@ -113,7 +113,11 @@ module RuboCop
 
           next if a.setter_method?
 
-          a.arguments.any? { |arg| within_node?(node, arg) }
+          a.arguments.any? do |arg|
+            within_node?(node, arg) && (kind == :with_or_without_parentheses ||
+                                        kind == :with_parentheses &&
+                                        parentheses?(node.parent))
+          end
         end
       end
 

data/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -35,7 +35,7 @@ module RuboCop
       end
 
       def space_required_after_lcurly?
-        cfg = config.for_cop('Style/SpaceInsideBlockBraces')
+        cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
         style = cfg['EnforcedStyle'] || 'space'
         style == 'space'
       end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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