rubocop 0.91.0 → 1.0.0

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

@@ -35,7 +35,6 @@ module RuboCop
       #     baz
       #   end
       class RescueType < Base
-        include RescueNode
         extend AutoCorrector
 
         MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \

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

@@ -75,8 +75,7 @@ module RuboCop
 
         def rescued_groups_for(rescues)
           rescues.map do |group|
-            rescue_group, = *group
-            evaluate_exceptions(rescue_group)
+            evaluate_exceptions(group)
           end
         end
 
@@ -117,14 +116,15 @@ module RuboCop
           $VERBOSE = old_verbose
         end
 
-        def evaluate_exceptions(rescue_group)
-          if rescue_group
-            rescued_exceptions = rescued_exceptions(rescue_group)
+        def evaluate_exceptions(group)
+          rescued_exceptions = group.exceptions
+
+          if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
                 silence_warnings do
                   # Avoid printing deprecation warnings about constants
-                  converted << Kernel.const_get(exception)
+                  converted << Kernel.const_get(exception.source)
                 end
               rescue NameError
                 converted << nil

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

@@ -31,7 +31,7 @@ module RuboCop
       class ToJSON < Base
         extend AutoCorrector
 
-        MSG = ' `#to_json` requires an optional argument to be parsable ' \
+        MSG = '`#to_json` requires an optional argument to be parsable ' \
           'via JSON.generate(obj).'
 
         def on_def(node)

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

@@ -159,16 +159,12 @@ module RuboCop
         end
 
         def preceded_by_continue_statement?(break_statement)
-          left_siblings_of(break_statement).any? do |sibling|
+          break_statement.left_siblings.any? do |sibling|
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(:next, :redo).any?
           end
         end
-
-        def left_siblings_of(node)
-          node.parent.children[0, node.sibling_index]
-        end
       end
     end
   end

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

@@ -131,12 +131,10 @@ module RuboCop
         MSG = 'Useless `%<current>s` access modifier.'
 
         def on_class(node)
-          check_node(node.children[2]) # class body
-        end
-
-        def on_module(node)
-          check_node(node.children[1]) # module body
+          check_node(node.body)
         end
+        alias on_module on_class
+        alias on_sclass on_class
 
         def on_block(node)
           return unless eval_call?(node)
@@ -144,10 +142,6 @@ module RuboCop
           check_node(node.body)
         end
 
-        def on_sclass(node)
-          check_node(node.children[1]) # singleton class body
-        end
-
         private
 
         def autocorrect(corrector, node)

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

@@ -49,7 +49,7 @@ module RuboCop
           add_offense(node, message: format(MSG, count: count)) do |corrector|
             next unless own_line?(node)
 
-            if count < 1
+            if never_process?(count, node)
               remove_node(corrector, node)
             elsif !proc_name.empty?
               autocorrect_block_pass(corrector, node, proc_name)
@@ -61,6 +61,10 @@ module RuboCop
 
         private
 
+        def never_process?(count, node)
+          count < 1 || node.block_type? && node.body.nil?
+        end
+
         def remove_node(corrector, node)
           corrector.remove(range_by_whole_lines(node.loc.expression, include_final_newline: true))
         end
@@ -82,7 +86,12 @@ module RuboCop
         def fix_indentation(source, range)
           # Cleanup indentation in a multiline block
           source_lines = source.split("\n")
-          source_lines[1..-1].each { |line| line[range] = '' }
+
+          source_lines[1..-1].each do |line|
+            next if line.empty?
+
+            line[range] = ''
+          end
           source_lines.join("\n")
         end
 

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

@@ -29,6 +29,8 @@ module RuboCop
       #       content.
       #     HEREDOC
       #   end                 # 5 points
+      #
+      # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
 
@@ -36,7 +38,7 @@ module RuboCop
 
         def on_block(node)
           return if excluded_method?(node)
-          return if node.class_constructor?
+          return if node.class_constructor? || node.struct_constructor?
 
           check_code_length(node)
         end

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

@@ -29,6 +29,8 @@ module RuboCop
       #     HEREDOC
       #   end                 # 5 points
       #
+      #
+      # NOTE: This cop also applies for `Struct` definitions.
       class ClassLength < Base
         include CodeLength
 
@@ -37,17 +39,23 @@ module RuboCop
         end
 
         def on_casgn(node)
-          class_definition?(node) do
-            check_code_length(node)
+          parent = node.parent
+
+          if parent&.assignment?
+            block_node = parent.children[1]
+          elsif parent&.parent&.masgn_type?
+            block_node = parent.parent.children[1]
+          else
+            _scope, _name, block_node = *node
           end
+
+          return unless block_node.respond_to?(:class_definition?) && block_node.class_definition?
+
+          check_code_length(block_node)
         end
 
         private
 
-        def_node_matcher :class_definition?, <<~PATTERN
-          (casgn nil? _ (block (send (const {nil? cbase} :Class) :new) ...))
-        PATTERN
-
         def message(length, max_length)
           format('Class has too many lines. [%<length>d/%<max>d]',
                  length: length,

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

@@ -12,6 +12,9 @@ module RuboCop
         MSG = 'Avoid parameter lists longer than %<max>d parameters. ' \
               '[%<count>d/%<max>d]'
 
+        NAMED_KEYWORD_TYPES = %i[kwoptarg kwarg].freeze
+        private_constant :NAMED_KEYWORD_TYPES
+
         def on_args(node)
           count = args_count(node)
           return unless count > max_params
@@ -33,7 +36,7 @@ module RuboCop
           if count_keyword_args?
             node.children.size
           else
-            node.children.count { |a| !%i[kwoptarg kwarg].include?(a.type) }
+            node.children.count { |a| !NAMED_KEYWORD_TYPES.include?(a.type) }
           end
         end
 

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -81,40 +81,49 @@ module RuboCop
           private
 
           def assignment?(node)
+            return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
+
             node.for_type? ||
-              node.op_asgn_type? ||
               (node.respond_to?(:setter_method?) && node.setter_method?) ||
-              (simple_assignment?(node) && capturing_variable?(node.children.first))
+              simple_assignment?(node) ||
+              argument?(node)
           end
 
-          def simple_assignment?(node)
-            return false if node.masgn_type?
+          def compound_assignment(node)
+            # Methods setter can not be detected for multiple assignments
+            # and shorthand assigns, so we'll count them here instead
+            children = node.masgn_type? ? node.children[0].children : node.children
 
-            if node.equals_asgn?
-              reset_on_lvasgn(node) if node.lvasgn_type?
-              return true
+            will_be_miscounted = children.count do |child|
+              child.respond_to?(:setter_method?) &&
+                !child.setter_method?
             end
+            @assignment += will_be_miscounted
 
-            argument?(node)
+            false
           end
 
-          def capturing_variable?(name)
-            name && !/^_/.match?(name)
+          def simple_assignment?(node)
+            if !node.equals_asgn?
+              false
+            elsif node.lvasgn_type?
+              reset_on_lvasgn(node)
+              capturing_variable?(node.children.first)
+            else
+              true
+            end
           end
 
-          # Returns true for nodes which otherwise would be counted
-          # as one too many assignment
-          def assignment_doubled_in_ast?(node)
-            node.masgn_type? || node.or_asgn_type? || node.and_asgn_type?
+          def capturing_variable?(name)
+            name && !/^_/.match?(name)
           end
 
           def branch?(node)
             BRANCH_NODES.include?(node.type)
           end
 
-          # TODO: move to rubocop-ast
           def argument?(node)
-            ARGUMENT_TYPES.include?(node.type)
+            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
           end
 
           def condition?(node)

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

@@ -8,9 +8,9 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case:  /(?:[a-z_]|_\d+)$/,
-        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
-        non_integer: /[A-Za-z_]$/
+        snake_case:  /(?:[[[:lower:]]_]|_\d+)$/,
+        normalcase:  /(?:_\D*|[[[:upper:]][[:lower:]]]\d*)$/,
+        non_integer: /[[[:upper:]][[:lower:]]_]$/
       }.freeze
     end
   end

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

@@ -137,7 +137,7 @@ module RuboCop
       end
 
       # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
         def self.from_each_with_object(node, match)
           new(match, node, 0, 0)
         end

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

@@ -18,6 +18,7 @@ module RuboCop
           @modifier_locations.include?(node.loc.keyword)
       end
 
+      # @deprecated Use ResbodyNode#exceptions instead
       def rescued_exceptions(resbody)
         rescue_group, = *resbody
         if rescue_group

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

@@ -57,10 +57,11 @@ module RuboCop
       end
 
       def first_line_comment(node)
-        comment =
-          processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        comment = processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        return unless comment
 
-        comment ? comment.loc.expression.source : nil
+        comment_source = comment.loc.expression.source
+        comment_source unless comment_disables_cop?(comment_source)
       end
 
       def parenthesize?(node)
@@ -80,6 +81,11 @@ module RuboCop
 
         config.for_cop('Layout/LineLength')['Max']
       end
+
+      def comment_disables_cop?(comment)
+        regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+        Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+      end
     end
   end
 end

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

@@ -16,32 +16,20 @@ module RuboCop
       end
 
       def find_visibility_start(node)
-        left_siblings_of(node)
-          .reverse
-          .find(&method(:visibility_block?))
+        node.left_siblings
+            .reverse
+            .find(&method(:visibility_block?))
       end
 
       # Navigate to find the last protected method
       def find_visibility_end(node)
         possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
-        right = right_siblings_of(node)
+        right = node.right_siblings
         right.find do |child_node|
           possible_visibilities.include?(node_visibility(child_node))
         end || right.last
       end
 
-      def left_siblings_of(node)
-        siblings_of(node)[0, node.sibling_index]
-      end
-
-      def right_siblings_of(node)
-        siblings_of(node)[node.sibling_index..-1]
-      end
-
-      def siblings_of(node)
-        node.parent.children
-      end
-
       def_node_matcher :visibility_block?, <<~PATTERN
         (send nil? { :private :protected :public })
       PATTERN

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -18,7 +18,7 @@ module RuboCop
               'name its argument `other`.'
 
         OP_LIKE_METHODS = %i[eql? equal?].freeze
-        EXCLUDED = %i[+@ -@ [] []= << === `].freeze
+        EXCLUDED = %i[+@ -@ [] []= << === ` =~].freeze
 
         def_node_matcher :op_method_candidate?, <<~PATTERN
           (def [#op_method? $_] (args $(arg [!:other !:_other])) _)

data/lib/rubocop/cop/offense.rb

@@ -63,10 +63,23 @@ module RuboCop
       attr_reader :corrector
 
       PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
-                                     :end_pos)
+                                     :end_pos) do
+        alias_method :first_line, :line
+        alias_method :last_line, :line
+        alias_method :last_column, :column
+
+        def column_range
+          column...last_column
+        end
+
+        def size
+          end_pos - begin_pos
+        end
+        alias_method :length, :size
+      end
       private_constant :PseudoSourceRange
 
-      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
+      NO_LOCATION = PseudoSourceRange.new(1, 0, '', 0, 0).freeze
 
       # @api private
       def initialize(severity, location, message, cop_name, # rubocop:disable Metrics/ParameterLists

data/lib/rubocop/cop/security/open.rb

@@ -3,35 +3,37 @@
 module RuboCop
   module Cop
     module Security
-      # This cop checks for the use of `Kernel#open`.
+      # This cop checks for the use of `Kernel#open` and `URI.open`.
       #
-      # `Kernel#open` enables not only file access but also process invocation
-      # by prefixing a pipe symbol (e.g., `open("| ls")`). So, it may lead to
-      # a serious security risk by using variable input to the argument of
-      # `Kernel#open`. It would be better to use `File.open`, `IO.popen` or
-      # `URI#open` explicitly.
+      # `Kernel#open` and `URI.open` enable not only file access but also process
+      # invocation by prefixing a pipe symbol (e.g., `open("| ls")`).
+      # So, it may lead to a serious security risk by using variable input to
+      # the argument of `Kernel#open` and `URI.open`. It would be better to use
+      # `File.open`, `IO.popen` or `URI.parse#open` explicitly.
       #
       # @example
       #   # bad
       #   open(something)
+      #   URI.open(something)
       #
       #   # good
       #   File.open(something)
       #   IO.popen(something)
       #   URI.parse(something).open
       class Open < Base
-        MSG = 'The use of `Kernel#open` is a serious security risk.'
+        MSG = 'The use of `%<receiver>sopen` is a serious security risk.'
         RESTRICT_ON_SEND = %i[open].freeze
 
         def_node_matcher :open?, <<~PATTERN
-          (send nil? :open $!str ...)
+          (send ${nil? (const {nil? cbase} :URI)} :open $!str ...)
         PATTERN
 
         def on_send(node)
-          open?(node) do |code|
+          open?(node) do |receiver, code|
             return if safe?(code)
 
-            add_offense(node.loc.selector)
+            message = format(MSG, receiver: receiver ? "#{receiver.source}." : 'Kernel#')
+            add_offense(node.loc.selector, message: message)
           end
         end