rubocop 1.10.0 → 1.11.0

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

@@ -37,6 +37,7 @@ module RuboCop
           end
         end
 
+        # @!method struct_constructor?(node)
         def_node_matcher :struct_constructor?, <<~PATTERN
           {(send (const {nil? cbase} :Struct) :new ...)
            (block (send (const {nil? cbase} :Struct) :new ...) ...)}

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Use symbols as procs when possible.
       #
+      # If you prefer a style that allows block for method with arguments,
+      # please set `true` to `AllowMethodsWithArguments`.
+      #
       # @example
       #   # bad
       #   something.map { |s| s.upcase }
@@ -12,6 +15,17 @@ module RuboCop
       #
       #   # good
       #   something.map(&:upcase)
+      #
+      # @example AllowMethodsWithArguments: false (default)
+      #   # bad
+      #   something.do_something(foo) { |o| o.bar }
+      #
+      #   # good
+      #   something.do_something(foo, &:bar)
+      #
+      # @example AllowMethodsWithArguments: true
+      #   # good
+      #   something.do_something(foo) { |o| o.bar }
       class SymbolProc < Base
         include RangeHelp
         include IgnoredMethods
@@ -21,8 +35,13 @@ module RuboCop
               'instead of a block.'
         SUPER_TYPES = %i[super zsuper].freeze
 
+        # @!method proc_node?(node)
         def_node_matcher :proc_node?, '(send (const {nil? cbase} :Proc) :new)'
+
+        # @!method symbol_proc_receiver?(node)
         def_node_matcher :symbol_proc_receiver?, '{(send ...) (super ...) zsuper}'
+
+        # @!method symbol_proc?(node)
         def_node_matcher :symbol_proc?, <<~PATTERN
           {
             (block $#symbol_proc_receiver? $(args (arg _var)) (send (lvar _var) $_))
@@ -37,11 +56,12 @@ module RuboCop
         def on_block(node)
           symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
             # TODO: Rails-specific handling that we should probably make
-            # configurable - https://github.com/rubocop-hq/rubocop/issues/1485
+            # configurable - https://github.com/rubocop/rubocop/issues/1485
             # we should ignore lambdas & procs
             return if proc_node?(dispatch_node)
             return if %i[lambda proc].include?(dispatch_node.method_name)
             return if ignored_method?(dispatch_node.method_name)
+            return if allow_if_method_has_argument?(node)
             return if node.block_type? && destructuring_block_argument?(arguments_node)
 
             register_offense(node, method_name, dispatch_node.method_name)
@@ -103,6 +123,10 @@ module RuboCop
             node.loc.begin.begin_pos
           end
         end
+
+        def allow_if_method_has_argument?(node)
+          !!cop_config.fetch('AllowMethodsWithArguments', false) && !node.arguments.count.zero?
+        end
       end
     end
   end

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

@@ -191,6 +191,7 @@ module RuboCop
             (child.send_type? && child.prefix_not?)
         end
 
+        # @!method method_name(node)
         def_node_matcher :method_name, <<~PATTERN
           {($:defined? _ ...)
            (send {_ nil?} $_ _ ...)}

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

@@ -34,6 +34,7 @@ module RuboCop
 
         def on_def(node)
           return unless trailing_body?(node)
+          return if node.endless? && node.body.parenthesized_call?
 
           add_offense(first_part_of(node.body)) do |corrector|
             LineBreakCorrector.correct_trailing_body(

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

@@ -40,7 +40,7 @@ module RuboCop
               'its own line.'
 
         def on_def(node)
-          return unless trailing_end?(node)
+          return if node.endless? || !trailing_end?(node)
 
           add_offense(node.loc.end) do |corrector|
             corrector.insert_before(

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

@@ -120,6 +120,7 @@ module RuboCop
             !allowed_method_name?(node) && !allowed_writer?(node.method_name)
         end
 
+        # @!method looks_like_trivial_writer?(node)
         def_node_matcher :looks_like_trivial_writer?, <<~PATTERN
           {(def    _ (args (arg ...)) (ivasgn _ (lvar _)))
            (defs _ _ (args (arg ...)) (ivasgn _ (lvar _)))}

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of logical operators in an `unless` condition.
+      # It discourages such code, as the condition becomes more difficult
+      # to read and understand.
+      #
+      # This cop supports two styles:
+      # - `forbid_mixed_logical_operators` (default)
+      # - `forbid_logical_operators`
+      #
+      # `forbid_mixed_logical_operators` style forbids the use of more than one type
+      # of logical operators. This makes the `unless` condition easier to read
+      # because either all conditions need to be met or any condition need to be met
+      # in order for the expression to be truthy or falsey.
+      #
+      # `forbid_logical_operators` style forbids any use of logical operator.
+      # This makes it even more easy to read the `unless` condition as
+      # there is only one condition in the expression.
+      #
+      # @example EnforcedStyle: forbid_mixed_logical_operators (default)
+      #   # bad
+      #   return unless a || b && c
+      #   return unless a && b || c
+      #   return unless a && b and c
+      #   return unless a || b or c
+      #   return unless a && b or c
+      #   return unless a || b and c
+      #
+      #   # good
+      #   return unless a && b && c
+      #   return unless a || b || c
+      #   return unless a and b and c
+      #   return unless a or b or c
+      #   return unless a?
+      #
+      # @example EnforcedStyle: forbid_logical_operators
+      #   # bad
+      #   return unless a || b
+      #   return unless a && b
+      #   return unless a or b
+      #   return unless a and b
+      #
+      #   # good
+      #   return unless a
+      #   return unless a?
+      class UnlessLogicalOperators < Base
+        include ConfigurableEnforcedStyle
+
+        FORBID_MIXED_LOGICAL_OPERATORS = 'Do not use mixed logical operators in an `unless`.'
+        FORBID_LOGICAL_OPERATORS = 'Do not use any logical operator in an `unless`.'
+
+        # @!method or_with_and?(node)
+        def_node_matcher :or_with_and?, <<~PATTERN
+          (if (or <`and ...> ) ...)
+        PATTERN
+
+        # @!method and_with_or?(node)
+        def_node_matcher :and_with_or?, <<~PATTERN
+          (if (and <`or ...> ) ...)
+        PATTERN
+
+        # @!method logical_operator?(node)
+        def_node_matcher :logical_operator?, <<~PATTERN
+          (if ({and or} ... ) ...)
+        PATTERN
+
+        def on_if(node)
+          return unless node.unless?
+
+          if style == :forbid_mixed_logical_operators && mixed_logical_operator?(node)
+            add_offense(node, message: FORBID_MIXED_LOGICAL_OPERATORS)
+          elsif style == :forbid_logical_operators && logical_operator?(node)
+            add_offense(node, message: FORBID_LOGICAL_OPERATORS)
+          end
+        end
+
+        private
+
+        def mixed_logical_operator?(node)
+          or_with_and?(node) ||
+            and_with_or?(node) ||
+            mixed_precedence_and?(node) ||
+            mixed_precedence_or?(node)
+        end
+
+        def mixed_precedence_and?(node)
+          node.source.include?('&&') && node.source.include?('and')
+        end
+
+        def mixed_precedence_or?(node)
+          node.source.include?('||') && node.source.include?('or')
+        end
+      end
+    end
+  end
+end

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

@@ -24,6 +24,7 @@ module RuboCop
           '`%<receiver>s.unpack(%<format>s)%<method>s`.'
         RESTRICT_ON_SEND = %i[first [] slice at].freeze
 
+        # @!method unpack_and_first_element?(node)
         def_node_matcher :unpack_and_first_element?, <<~PATTERN
           {
             (send $(send (...) :unpack $(...)) :first)

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

@@ -72,6 +72,7 @@ module RuboCop
 
         PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
 
+        # @!method file_constant_equal_program_name?(node)
         def_node_matcher :file_constant_equal_program_name?, <<~PATTERN
           (send #source_file_path_constant? {:== :!=} (gvar #program_name?))
         PATTERN

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

@@ -71,6 +71,7 @@ module RuboCop
           end
         end
 
+        # @!method zero_length_predicate(node)
         def_node_matcher :zero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) $:== (int $0))
            (send (int $0) $:== (send (...) ${:length :size}))
@@ -78,6 +79,7 @@ module RuboCop
            (send (int $1) $:> (send (...) ${:length :size}))}
         PATTERN
 
+        # @!method nonzero_length_predicate(node)
         def_node_matcher :nonzero_length_predicate, <<~PATTERN
           {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
            (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
@@ -90,6 +92,7 @@ module RuboCop
           "!#{other_receiver(node).source}.empty?"
         end
 
+        # @!method zero_length_receiver(node)
         def_node_matcher :zero_length_receiver, <<~PATTERN
           {(send (send $_ _) :== (int 0))
            (send (int 0) :== (send $_ _))
@@ -97,6 +100,7 @@ module RuboCop
            (send (int 1) :> (send $_ _))}
         PATTERN
 
+        # @!method other_receiver(node)
         def_node_matcher :other_receiver, <<~PATTERN
           {(send (send $_ _) _ _)
            (send _ _ (send $_ _))}
@@ -105,6 +109,7 @@ module RuboCop
         # Some collection like objects in the Ruby standard library
         # implement `#size`, but not `#empty`. We ignore those to
         # reduce false positives.
+        # @!method non_polymorphic_collection?(node)
         def_node_matcher :non_polymorphic_collection?, <<~PATTERN
           {(send (send (send (const {nil? cbase} :File) :stat _) ...) ...)
            (send (send (send (const {nil? cbase} {:Tempfile :StringIO}) {:new :open} ...) ...) ...)}

data/lib/rubocop/name_similarity.rb

@@ -16,7 +16,7 @@ module RuboCop
       # DidYouMean::SpellChecker is not available in all versions of Ruby, and
       # even on versions where it *is* available (>= 2.3), it is not always
       # required correctly. So we do a feature check first.
-      # See: https://github.com/rubocop-hq/rubocop/issues/7979
+      # See: https://github.com/rubocop/rubocop/issues/7979
       return [] unless defined?(DidYouMean::SpellChecker)
 
       names = names.dup

data/lib/rubocop/target_ruby.rb

@@ -147,10 +147,12 @@ module RuboCop
 
       GEMSPEC_EXTENSION = '.gemspec'
 
+      # @!method required_ruby_version(node)
       def_node_search :required_ruby_version, <<~PATTERN
         (send _ :required_ruby_version= $_)
       PATTERN
 
+      # @!method gem_requirement?(node)
       def_node_matcher :gem_requirement?, <<~PATTERN
         (send (const(const _ :Gem):Requirement) :new $str)
       PATTERN
@@ -165,14 +167,10 @@ module RuboCop
         file = gemspec_filepath
         return unless file && File.file?(file)
 
-        version = version_from_gemspec_file(file)
-        return if version.nil?
+        right_hand_side = version_from_gemspec_file(file)
+        return if right_hand_side.nil?
 
-        requirement = version.children.last
-        return version_from_array(version) if version.array_type?
-        return version_from_array(requirement) if gem_requirement? version
-
-        version_from_str(version.str_content)
+        find_minimal_known_ruby(right_hand_side)
       end
 
       def gemspec_filename
@@ -192,15 +190,25 @@ module RuboCop
         required_ruby_version(processed_source.ast).first
       end
 
+      def version_from_right_hand_side(right_hand_side)
+        if right_hand_side.array_type?
+          version_from_array(right_hand_side)
+        elsif gem_requirement?(right_hand_side)
+          right_hand_side.children.last.value
+        else
+          right_hand_side.value
+        end
+      end
+
       def version_from_array(array)
-        versions = array.children.map { |v| version_from_str(v.is_a?(String) ? v : v.str_content) }
-        versions.compact.min
+        array.children.map(&:value)
       end
 
-      def version_from_str(str)
-        str.match(/^(?:>=|<=)?\s*(?<version>\d+(?:\.\d+)*)/) do |md|
-          md[:version].to_f
-        end
+      def find_minimal_known_ruby(right_hand_side)
+        version = version_from_right_hand_side(right_hand_side)
+        requirement = Gem::Requirement.new(version)
+
+        KNOWN_RUBIES.detect { |v| requirement.satisfied_by?(Gem::Version.new("#{v}.99")) }
       end
     end
 

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.10.0'
+    STRING = '1.11.0'
 
     MSG = '%<version>s (using Parser %<parser_version>s, '\
           'rubocop-ast %<rubocop_ast_version>s, ' \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.11.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-02-15 00:00:00.000000000 Z
+date: 2021-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -258,6 +258,7 @@ files:
 - lib/rubocop/cop/internal_affairs/example_description.rb
 - lib/rubocop/cop/internal_affairs/method_name_equal.rb
 - lib/rubocop/cop/internal_affairs/node_destructuring.rb
+- lib/rubocop/cop/internal_affairs/node_matcher_directive.rb
 - lib/rubocop/cop/internal_affairs/node_type_predicate.rb
 - lib/rubocop/cop/internal_affairs/offense_location_keyword.rb
 - lib/rubocop/cop/internal_affairs/redundant_described_class_as_subject.rb
@@ -790,6 +791,7 @@ files:
 - lib/rubocop/cop/style/trailing_underscore_variable.rb
 - lib/rubocop/cop/style/trivial_accessors.rb
 - lib/rubocop/cop/style/unless_else.rb
+- lib/rubocop/cop/style/unless_logical_operators.rb
 - lib/rubocop/cop/style/unpack_first.rb
 - lib/rubocop/cop/style/variable_interpolation.rb
 - lib/rubocop/cop/style/when_then.rb
@@ -861,15 +863,15 @@ files:
 - lib/rubocop/version.rb
 - lib/rubocop/warning.rb
 - lib/rubocop/yaml_duplication_checker.rb
-homepage: https://github.com/rubocop-hq/rubocop
+homepage: https://github.com/rubocop/rubocop
 licenses:
 - MIT
 metadata:
   homepage_uri: https://rubocop.org/
-  changelog_uri: https://github.com/rubocop-hq/rubocop/blob/master/CHANGELOG.md
-  source_code_uri: https://github.com/rubocop-hq/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.10/
-  bug_tracker_uri: https://github.com/rubocop-hq/rubocop/issues
+  changelog_uri: https://github.com/rubocop/rubocop/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/rubocop/rubocop/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.11/
+  bug_tracker_uri: https://github.com/rubocop/rubocop/issues
 post_install_message: 
 rdoc_options: []
 require_paths: