rubocop 1.69.2 → 1.71.2

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

@@ -43,7 +43,7 @@ module RuboCop
         PATTERN
 
         def parent_block_node(node)
-          node.each_ancestor(:block, :numblock).first
+          node.each_ancestor(:any_block).first
         end
       end
     end

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

@@ -59,12 +59,12 @@ module RuboCop
 
         # @!method send_exist_node(node)
         def_node_search :send_exist_node, <<~PATTERN
-          $(send (const nil? {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
+          $(send (const {cbase nil?} {:FileTest :File :Dir :Shell}) {:exist? :exists?} ...)
         PATTERN
 
         # @!method receiver_and_method_name(node)
         def_node_matcher :receiver_and_method_name, <<~PATTERN
-          (send (const nil? $_) $_ ...)
+          (send (const {cbase nil?} $_) $_ ...)
         PATTERN
 
         # @!method force?(node)
@@ -78,7 +78,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.receiver
+          return unless node.receiver&.const_type?
           return unless if_node_child?(node)
           return if explicit_not_force?(node)
           return unless (exist_node = send_exist_node(node.parent).first)
@@ -116,6 +116,7 @@ module RuboCop
 
         def message_remove_file_exist_check(node)
           receiver, method_name = receiver_and_method_name(node)
+
           format(MSG_REMOVE_FILE_EXIST_CHECK, receiver: receiver, method_name: method_name)
         end
 

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

@@ -66,7 +66,7 @@ module RuboCop
         private
 
         def scoped_node?(node)
-          node.def_type? || node.defs_type? || node.lambda?
+          node.type?(:def, :defs) || node.lambda?
         end
 
         def return_value?(return_node)

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

@@ -4,30 +4,27 @@ module RuboCop
   module Cop
     module Lint
       # Certain numeric operations have a constant result, usually 0 or 1.
-      # Subtracting a number from itself or multiplying it by 0 will always return 0.
-      # Additionally, a variable modulo 0 or itself will always return 0.
+      # Multiplying a number by 0 will always return 0.
       # Dividing a number by itself or raising it to the power of 0 will always return 1.
       # As such, they can be replaced with that result.
       # These are probably leftover from debugging, or are mistakes.
       # Other numeric operations that are similarly leftover from debugging or mistakes
-      # are handled by Lint/UselessNumericOperation.
+      # are handled by `Lint/UselessNumericOperation`.
+      #
+      # NOTE: This cop doesn't detect offenses for the `-` and `%` operator because it
+      # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
+      # a numeric operation.
       #
       # @example
       #
       #   # bad
-      #   x - x
       #   x * 0
-      #   x % 1
-      #   x % x
       #
       #   # good
       #   0
       #
       #   # bad
-      #   x -= x
       #   x *= 0
-      #   x %= 1
-      #   x %= x
       #
       #   # good
       #   x = 0
@@ -49,57 +46,47 @@ module RuboCop
       class NumericOperationWithConstantResult < Base
         extend AutoCorrector
         MSG = 'Numeric operation with a constant result detected.'
-        RESTRICT_ON_SEND = %i[- * / % **].freeze
+        RESTRICT_ON_SEND = %i[* / **].freeze
 
         # @!method operation_with_constant_result?(node)
         def_node_matcher :operation_with_constant_result?,
-                         '(send (send nil? $_) $_ ({int | send nil?} $_))'
+                         '(call (call nil? $_lhs) $_operation ({int | call nil?} $_rhs))'
 
         # @!method abbreviated_assignment_with_constant_result?(node)
         def_node_matcher :abbreviated_assignment_with_constant_result?,
-                         '(op-asgn (lvasgn $_) $_ ({int | lvar} $_))'
+                         '(op-asgn (lvasgn $_lhs) $_operation ({int lvar} $_rhs))'
 
         def on_send(node)
-          return unless operation_with_constant_result?(node)
-
-          variable, operation, number = operation_with_constant_result?(node)
-          result = constant_result?(variable, operation, number)
-          return unless result
+          return unless (lhs, operation, rhs = operation_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
 
           add_offense(node) do |corrector|
             corrector.replace(node, result.to_s)
           end
         end
+        alias on_csend on_send
 
         def on_op_asgn(node)
-          return unless abbreviated_assignment_with_constant_result?(node)
-
-          variable, operation, number = abbreviated_assignment_with_constant_result?(node)
-          result = constant_result?(variable, operation, number)
-          return unless result
+          return unless (lhs, operation, rhs = abbreviated_assignment_with_constant_result?(node))
+          return unless (result = constant_result?(lhs, operation, rhs))
 
           add_offense(node) do |corrector|
-            corrector.replace(node, "#{variable} = #{result}")
+            corrector.replace(node, "#{lhs} = #{result}")
           end
         end
 
         private
 
-        # rubocop :disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        def constant_result?(variable, operation, number)
-          if number.to_s == '0'
+        def constant_result?(lhs, operation, rhs)
+          if rhs.to_s == '0'
             return 0 if operation == :*
             return 1 if operation == :**
-          elsif number.to_s == '1'
-            return 0 if operation == :%
-          elsif number == variable
-            return 0 if %i[- %].include?(operation)
+          elsif rhs == lhs
             return 1 if operation == :/
           end
           # If we weren't able to find any matches, return false so we can bail out.
           false
         end
-        # rubocop :enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Looks for references of Regexp captures that are out of range
+      # Looks for references of `Regexp` captures that are out of range
       # and thus always returns nil.
       #
       # @safety
@@ -61,6 +61,7 @@ module RuboCop
             check_regexp(node.receiver)
           end
         end
+        alias after_csend after_send
 
         def on_when(node)
           regexp_conditions = node.conditions.select(&:regexp_type?)

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

@@ -38,16 +38,12 @@ module RuboCop
 
         def valid_context?(node)
           return true unless node.arguments.one? && node.first_argument.parenthesized_call?
-          return true if first_argument_block_type?(node.first_argument)
+          return true if node.first_argument.any_block_type?
 
           node.operator_method? || node.setter_method? || chained_calls?(node) ||
             valid_first_argument?(node.first_argument)
         end
 
-        def first_argument_block_type?(first_arg)
-          first_arg.block_type? || first_arg.numblock_type?
-        end
-
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg) ||
             compound_range?(first_arg)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for redundant quantifiers inside Regexp literals.
+      # Checks for redundant quantifiers inside `Regexp` literals.
       #
       # It is always allowed when interpolation is used in a regexp literal,
       # because it's unknown what kind of string will be expanded as a result:

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

@@ -29,7 +29,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[print puts warn].freeze
 
         # @!method to_s_without_args?(node)
-        def_node_matcher :to_s_without_args?, '(send _ :to_s)'
+        def_node_matcher :to_s_without_args?, '(call _ :to_s)'
 
         def on_interpolation(begin_node)
           final_node = begin_node.children.last
@@ -42,7 +42,7 @@ module RuboCop
         def on_send(node)
           return if node.receiver
 
-          node.each_child_node(:send) do |child|
+          node.each_child_node(:call) do |child|
             next if !child.method?(:to_s) || child.arguments.any?
 
             register_offense(child, "`#{node.method_name}`")

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for `rescue` blocks targeting the Exception class.
+      # Checks for `rescue` blocks targeting the `Exception` class.
       #
       # @example
       #

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

@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :bad_method?, <<~PATTERN
           {
             (send $(csend ...) $_ ...)
-            (send $({block numblock} (csend ...) ...) $_ ...)
+            (send $(any_block (csend ...) ...) $_ ...)
           }
         PATTERN
 
@@ -97,12 +97,19 @@ module RuboCop
         end
 
         def require_parentheses?(send_node)
+          return true if operator_inside_hash?(send_node)
           return false unless send_node.comparison_method?
           return false unless (node = send_node.parent)
 
           (node.respond_to?(:logical_operator?) && node.logical_operator?) ||
             (node.respond_to?(:comparison_method?) && node.comparison_method?)
         end
+
+        def operator_inside_hash?(send_node)
+          # If an operator call (without a dot) is inside a hash, it needs
+          # to be parenthesized when converted to safe navigation.
+          send_node.parent&.pair_type? && !send_node.loc.dot
+        end
       end
     end
   end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for `Hash` creation with a mutable default value.
+      # Creating a `Hash` in such a way will share the default value
+      # across all keys, causing unexpected behavior when modifying it.
+      #
+      # For example, when the `Hash` was created with an `Array` as the argument,
+      # calling `hash[:foo] << 'bar'` will also change the value of all
+      # other keys that have not been explicitly assigned to.
+      #
+      # @example
+      #   # bad
+      #   Hash.new([])
+      #   Hash.new({})
+      #   Hash.new(Array.new)
+      #   Hash.new(Hash.new)
+      #
+      #   # okay -- In rare cases that intentionally have this behavior,
+      #   #   without disabling the cop, you can set the default explicitly.
+      #   h = Hash.new
+      #   h.default = []
+      #   h[:a] << 1
+      #   h[:b] << 2
+      #   h # => {:a => [1, 2], :b => [1, 2]}
+      #
+      #   # okay -- beware this will discard mutations and only remember assignments
+      #   Hash.new { Array.new }
+      #   Hash.new { Hash.new }
+      #   Hash.new { {} }
+      #   Hash.new { [] }
+      #
+      #   # good - frozen solution will raise an error when mutation attempted
+      #   Hash.new([].freeze)
+      #   Hash.new({}.freeze)
+      #
+      #   # good - using a proc will create a new object for each key
+      #   h = Hash.new
+      #   h.default_proc = ->(h, k) { [] }
+      #   h.default_proc = ->(h, k) { {} }
+      #
+      #   # good - using a block will create a new object for each key
+      #   Hash.new { |h, k| h[k] = [] }
+      #   Hash.new { |h, k| h[k] = {} }
+      class SharedMutableDefault < Base
+        MSG = 'Do not create a Hash with a mutable default value ' \
+              'as the default value can accidentally be changed.'
+        RESTRICT_ON_SEND = %i[new].freeze
+
+        # @!method hash_initialized_with_mutable_shared_object?(node)
+        def_node_matcher :hash_initialized_with_mutable_shared_object?, <<~PATTERN
+          (send (const {nil? cbase} :Hash) :new {array hash (send (const {nil? cbase} {:Array :Hash}) :new)})
+        PATTERN
+
+        def on_send(node)
+          return unless hash_initialized_with_mutable_shared_object?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -116,7 +116,7 @@ module RuboCop
         private
 
         def comment_between_rescue_and_end?(node)
-          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :block, :numblock).first
+          ancestor = node.each_ancestor(:kwbegin, :def, :defs, :any_block).first
           return false unless ancestor
 
           end_line = ancestor.loc.end&.line || ancestor.loc.last_line

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

@@ -78,7 +78,7 @@ module RuboCop
         def on_send(node)
           return unless node.receiver
 
-          if node.receiver.str_type? || node.receiver.sym_type?
+          if node.receiver.type?(:str, :sym)
             register_offense(node, correction: node.receiver.value.to_sym.inspect)
           elsif node.receiver.dstr_type?
             register_offense(node, correction: ":\"#{node.receiver.value.to_sym}\"")

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

@@ -6,9 +6,12 @@ module RuboCop
       # Repacks Parser's diagnostics/errors
       # into RuboCop's offenses.
       class Syntax < Base
+        LEVELS = %i[error fatal].freeze
+
         def on_other_file
           add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
-          processed_source.diagnostics.each do |diagnostic|
+          syntax_errors = processed_source.diagnostics.select { |d| LEVELS.include?(d.level) }
+          syntax_errors.each do |diagnostic|
             add_offense_from_diagnostic(diagnostic, processed_source.ruby_version)
           end
           super

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

@@ -55,12 +55,9 @@ module RuboCop
           return if node.each_descendant(:dstr).any?
 
           regexp_constructor(node) do |text|
-            Regexp::Parser.parse(text.value)&.each_expression do |expr|
+            parse_regexp(text.value)&.each_expression do |expr|
               detect_offenses(text, expr)
             end
-          rescue Regexp::Parser::Error
-            # Upon encountering an invalid regular expression,
-            # we aim to proceed and identify any remaining potential offenses.
           end
         end
 

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

@@ -81,7 +81,7 @@ module RuboCop
           node.arguments.count do |arg|
             return Float::INFINITY if arg.restarg_type?
 
-            arg.arg_type? || arg.optarg_type? || arg.mlhs_type?
+            arg.type?(:arg, :optarg, :mlhs)
           end
         end
       end

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

@@ -130,7 +130,7 @@ module RuboCop
 
           block_body_node.each_descendant(:next, :break) do |n|
             # Ignore `next`/`break` inside an inner block
-            next if n.each_ancestor(:block).first != block_body_node.parent
+            next if n.each_ancestor(:any_block).first != block_body_node.parent
             next unless n.first_argument
 
             nodes << n.first_argument

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

@@ -117,7 +117,7 @@ module RuboCop
         end
 
         def instance_eval_block?(node)
-          node.block_type? && node.method?(:instance_eval)
+          node.any_block_type? && node.method?(:instance_eval)
         end
 
         def report_on_flow_command?(node)

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

@@ -108,7 +108,7 @@ module RuboCop
         private
 
         def loop_method?(node)
-          return false unless node.block_type? || node.numblock_type?
+          return false unless node.any_block_type?
 
           send_node = node.send_node
           loopable = send_node.enumerable_method? || send_node.enumerator_method? ||

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

@@ -159,12 +159,12 @@ module RuboCop
 
         # @!method dynamic_method_definition?(node)
         def_node_matcher :dynamic_method_definition?, <<~PATTERN
-          {(send nil? :define_method ...) ({block numblock} (send nil? :define_method ...) ...)}
+          {(send nil? :define_method ...) (any_block (send nil? :define_method ...) ...)}
         PATTERN
 
         # @!method class_or_instance_eval?(node)
         def_node_matcher :class_or_instance_eval?, <<~PATTERN
-          ({block numblock} (send _ {:class_eval :instance_eval}) ...)
+          (any_block (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
         def check_node(node)
@@ -268,7 +268,7 @@ module RuboCop
         end
 
         def start_of_new_scope?(child)
-          child.module_type? || child.class_type? || child.sclass_type? || eval_call?(child)
+          child.type?(:module, :class, :sclass) || eval_call?(child)
         end
 
         def eval_call?(child)
@@ -282,7 +282,7 @@ module RuboCop
             matcher_name = :"#{m}_block?"
             unless respond_to?(matcher_name)
               self.class.def_node_matcher matcher_name, <<~PATTERN
-                ({block numblock} (send {nil? const} {:#{m}} ...) ...)
+                (any_block (send {nil? const} {:#{m}} ...) ...)
               PATTERN
             end
 

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

@@ -17,7 +17,7 @@ module RuboCop
       # rescue, ensure, etc.
       #
       # This cop's autocorrection avoids cases like `a ||= 1` because removing assignment from
-      # operator assignment can cause NameError if this assignment has been used to declare
+      # operator assignment can cause `NameError` if this assignment has been used to declare
       # a local variable. For example, replacing `a ||= 1` with `a || 1` may cause
       # "undefined local variable or method `a' for main:Object (NameError)".
       #

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

@@ -59,7 +59,7 @@ module RuboCop
         end
 
         def use_rest_or_optional_args?(node)
-          node.arguments.any? { |arg| arg.restarg_type? || arg.optarg_type? || arg.kwoptarg_type? }
+          node.arguments.any? { |arg| arg.type?(:restarg, :optarg, :kwoptarg) }
         end
 
         def delegating?(node, def_node)

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

@@ -35,7 +35,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[+ - * / **].freeze
 
         # @!method useless_operation?(node)
-        def_node_matcher :useless_operation?, '(send (send nil? $_) $_ (int $_))'
+        def_node_matcher :useless_operation?, '(call (call nil? $_) $_ (int $_))'
 
         # @!method useless_abbreviated_assignment?(node)
         def_node_matcher :useless_abbreviated_assignment?, '(op-asgn (lvasgn $_) $_ (int $_))'
@@ -50,6 +50,7 @@ module RuboCop
             corrector.replace(node, variable)
           end
         end
+        alias on_csend on_send
 
         def on_op_asgn(node)
           return unless useless_abbreviated_assignment?(node)

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

@@ -72,7 +72,7 @@ module RuboCop
         def_node_matcher :method_definition, <<~PATTERN
           {
             (def %1 ...)
-            ({block numblock} (send _ :define_method (sym %1)) ...)
+            (any_block (send _ :define_method (sym %1)) ...)
           }
         PATTERN
 
@@ -108,7 +108,7 @@ module RuboCop
 
         def find_method_definition(node, method_name)
           node.each_ancestor.lazy.map do |ancestor|
-            ancestor.each_child_node(:def, :block, :numblock).find do |child|
+            ancestor.each_child_node(:def, :any_block).find do |child|
               method_definition(child, method_name)
             end
           end.find(&:itself)

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

@@ -103,7 +103,7 @@ module RuboCop
           expressions.pop unless in_void_context?(node)
           expressions.each do |expr|
             check_void_op(expr) do
-              block_node = node.each_ancestor(:block).first
+              block_node = node.each_ancestor(:any_block).first
 
               block_node&.method?(:each)
             end
@@ -113,7 +113,8 @@ module RuboCop
         end
 
         def check_expression(expr)
-          expr = expr.body if expr.if_type? && expr.modifier_form?
+          expr = expr.body if expr.if_type?
+          return unless expr
 
           check_literal(expr)
           check_var(expr)
@@ -178,7 +179,7 @@ module RuboCop
         end
 
         def check_nonmutating(node)
-          return if !node.send_type? && !node.block_type? && !node.numblock_type?
+          return unless node.type?(:send, :any_block)
 
           method_name = node.method_name
           return unless NONMUTATING_METHODS.include?(method_name)
@@ -200,11 +201,6 @@ module RuboCop
           # NOTE: the `begin` node case is already handled via `on_begin`
           return if body.begin_type?
 
-          check_void_op(body) do
-            block_node = node.each_ancestor(:block).first
-            block_node&.method?(:each)
-          end
-
           check_expression(body)
         end
 
@@ -229,7 +225,7 @@ module RuboCop
         end
 
         def autocorrect_void_expression(corrector, node)
-          return if node.parent.if_type? && node.parent.modifier_form?
+          return if node.parent.if_type?
 
           corrector.remove(range_with_surrounding_space(range: node.source_range, side: :left))
         end

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

@@ -52,7 +52,7 @@ module RuboCop
         def consider_node?(node)
           return true if NESTING_BLOCKS.include?(node.type)
 
-          count_blocks? && (node.block_type? || node.numblock_type?)
+          count_blocks? && node.any_block_type?
         end
 
         def message(max)

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

@@ -52,12 +52,19 @@ module RuboCop
               'Prefer reading the data from an external source.'
         RESTRICT_ON_SEND = [:[]].freeze
 
+        # @!method set_const?(node)
+        def_node_matcher :set_const?, <<~PATTERN
+          (const {cbase nil?} :Set)
+        PATTERN
+
         def on_array(node)
           add_offense(node) if node.children.length >= collection_threshold
         end
         alias on_hash on_array
 
         def on_index(node)
+          return unless set_const?(node.receiver)
+
           add_offense(node) if node.arguments.length >= collection_threshold
         end
 

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

@@ -36,7 +36,7 @@ module RuboCop
         include MethodComplexity
         include Utils::IteratingBlock
 
-        MSG = 'Cyclomatic complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        MSG = 'Cyclomatic complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
         COUNTED_NODES = %i[if while until for csend block block_pass
                            rescue when in_pattern and or or_asgn and_asgn].freeze
 

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

@@ -48,7 +48,7 @@ module RuboCop
         LABEL = 'Method'
 
         def on_def(node)
-          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
+          return if allowed?(node.method_name)
 
           check_code_length(node)
         end
@@ -57,6 +57,9 @@ module RuboCop
         def on_block(node)
           return unless node.method?(:define_method)
 
+          method_name = node.send_node.first_argument
+          return if method_name.basic_literal? && allowed?(method_name.value)
+
           check_code_length(node)
         end
         alias on_numblock on_block
@@ -66,6 +69,10 @@ module RuboCop
         def cop_label
           LABEL
         end
+
+        def allowed?(method_name)
+          allowed_method?(method_name) || matches_allowed_pattern?(method_name)
+        end
       end
     end
   end

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

@@ -50,7 +50,7 @@ module RuboCop
 
         # @!method module_definition?(node)
         def_node_matcher :module_definition?, <<~PATTERN
-          (casgn nil? _ ({block numblock} (send (const {nil? cbase} :Module) :new) ...))
+          (casgn nil? _ (any_block (send (const {nil? cbase} :Module) :new) ...))
         PATTERN
 
         def message(length, max_length)

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

@@ -27,7 +27,7 @@ module RuboCop
       #     end                           # ===
       #   end                             # 7 complexity points
       class PerceivedComplexity < CyclomaticComplexity
-        MSG = 'Perceived complexity for %<method>s is too high. [%<complexity>d/%<max>d]'
+        MSG = 'Perceived complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
 
         COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze