op_connect 0.1.2 → 0.1.3

data/vendor/bundle/ruby/3.1.0/gems/rubocop-1.26.0/lib/rubocop/cop/lint/useless_method_definition.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for useless method definitions, specifically: empty constructors
-      # and methods just delegating to `super`.
-      #
-      # @safety
-      #   This cop is unsafe as it can register false positives for cases when an empty
-      #   constructor just overrides the parent constructor, which is bad anyway.
-      #
-      # @example
-      #   # bad
-      #   def initialize
-      #     super
-      #   end
-      #
-      #   def method
-      #     super
-      #   end
-      #
-      #   # good - with default arguments
-      #   def initialize(x = Object.new)
-      #     super
-      #   end
-      #
-      #   # good
-      #   def initialize
-      #     super
-      #     initialize_internals
-      #   end
-      #
-      #   def method(*args)
-      #     super(:extra_arg, *args)
-      #   end
-      #
-      class UselessMethodDefinition < Base
-        extend AutoCorrector
-
-        MSG = 'Useless method definition detected.'
-
-        def on_def(node)
-          return if optional_args?(node)
-          return unless delegating?(node.body, node)
-
-          add_offense(node) { |corrector| corrector.remove(node) }
-        end
-        alias on_defs on_def
-
-        private
-
-        def optional_args?(node)
-          node.arguments.any? { |arg| arg.optarg_type? || arg.kwoptarg_type? }
-        end
-
-        def delegating?(node, def_node)
-          if node&.zsuper_type?
-            true
-          elsif node&.super_type?
-            node.arguments.map(&:source) == def_node.arguments.map(&:source)
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rubocop-1.26.0/lib/rubocop/cop/lint/useless_ruby2_keywords.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop looks for `ruby2_keywords` calls for methods that do not need it.
-      #
-      # `ruby2_keywords` should only be called on methods that accept an argument splat
-      # (`*args`) but do not explicit keyword arguments (`k:` or `k: true`) or
-      # a keyword splat (`**kwargs`).
-      #
-      # @example
-      #   # good (splat argument without keyword arguments)
-      #   ruby2_keywords def foo(*args); end
-      #
-      #   # bad (no arguments)
-      #   ruby2_keywords def foo; end
-      #
-      #   # good
-      #   def foo; end
-      #
-      #   # bad (positional argument)
-      #   ruby2_keywords def foo(arg); end
-      #
-      #   # good
-      #   def foo(arg); end
-      #
-      #   # bad (double splatted argument)
-      #   ruby2_keywords def foo(**args); end
-      #
-      #   # good
-      #   def foo(**args); end
-      #
-      #   # bad (keyword arguments)
-      #   ruby2_keywords def foo(i:, j:); end
-      #
-      #   # good
-      #   def foo(i:, j:); end
-      #
-      #   # bad (splat argument with keyword arguments)
-      #   ruby2_keywords def foo(*args, i:, j:); end
-      #
-      #   # good
-      #   def foo(*args, i:, j:); end
-      #
-      #   # bad (splat argument with double splat)
-      #   ruby2_keywords def foo(*args, **kwargs); end
-      #
-      #   # good
-      #   def foo(*args, **kwargs); end
-      #
-      #   # bad (ruby2_keywords given a symbol)
-      #   def foo; end
-      #   ruby2_keywords :foo
-      #
-      #   # good
-      #   def foo; end
-      #
-      #   # bad (ruby2_keywords with dynamic method)
-      #   define_method(:foo) { |arg| }
-      #   ruby2_keywords :foo
-      #
-      #   # good
-      #   define_method(:foo) { |arg| }
-      #
-      class UselessRuby2Keywords < Base
-        MSG = '`ruby2_keywords` is unnecessary for method `%<method_name>s`.'
-        RESTRICT_ON_SEND = %i[ruby2_keywords].freeze
-
-        # Looks for statically or dynamically defined methods with a given name
-        # @!method method_definition(node, method_name)
-        def_node_matcher :method_definition, <<~PATTERN
-          {
-            (def %1 ...)
-            ({block numblock} (send _ :define_method (sym %1)) ...)
-          }
-        PATTERN
-
-        def on_send(node)
-          if node.first_argument.def_type?
-            inspect_def(node, node.first_argument)
-          elsif node.first_argument.sym_type?
-            inspect_sym(node, node.first_argument)
-          end
-        end
-
-        private
-
-        def inspect_def(node, def_node)
-          return if allowed_arguments(def_node.arguments)
-
-          add_offense(node.loc.selector, message: format(MSG, method_name: def_node.method_name))
-        end
-
-        def inspect_sym(node, sym_node)
-          return unless node.parent
-
-          method_name = sym_node.value
-          definition = node.parent.each_child_node.detect { |n| method_definition(n, method_name) }
-
-          return unless definition
-          return if allowed_arguments(definition.arguments)
-
-          add_offense(node, message: format(MSG, method_name: method_name))
-        end
-
-        # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments
-        def allowed_arguments(arguments)
-          return false if arguments.empty?
-
-          arguments.each_child_node(:restarg).any? &&
-            arguments.each_child_node(:kwarg, :kwoptarg, :kwrestarg).none?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rubocop-1.26.0/lib/rubocop/cop/lint/useless_setter_call.rb

@@ -1,173 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for setter call to local variable as the final
-      # expression of a function definition.
-      #
-      # @safety
-      #   There are edge cases in which the local variable references a
-      #   value that is also accessible outside the local scope. This is not
-      #   detected by the cop, and it can yield a false positive.
-      #
-      #   As well, auto-correction is unsafe because the method's
-      #   return value will be changed.
-      #
-      # @example
-      #
-      #   # bad
-      #
-      #   def something
-      #     x = Something.new
-      #     x.attr = 5
-      #   end
-      #
-      # @example
-      #
-      #   # good
-      #
-      #   def something
-      #     x = Something.new
-      #     x.attr = 5
-      #     x
-      #   end
-      class UselessSetterCall < Base
-        extend AutoCorrector
-
-        MSG = 'Useless setter call to local variable `%<variable>s`.'
-        ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn].freeze
-
-        def on_def(node)
-          return unless node.body
-
-          last_expr = last_expression(node.body)
-          return unless setter_call_to_local_variable?(last_expr)
-
-          tracker = MethodVariableTracker.new(node.body)
-          receiver, = *last_expr
-          variable_name, = *receiver
-          return unless tracker.contain_local_object?(variable_name)
-
-          loc_name = receiver.loc.name
-
-          add_offense(loc_name, message: format(MSG, variable: loc_name.source)) do |corrector|
-            corrector.insert_after(last_expr, "\n#{indent(last_expr)}#{loc_name.source}")
-          end
-        end
-        alias on_defs on_def
-
-        private
-
-        # @!method setter_call_to_local_variable?(node)
-        def_node_matcher :setter_call_to_local_variable?, <<~PATTERN
-          [(send (lvar _) ...) setter_method?]
-        PATTERN
-
-        def last_expression(body)
-          expression = body.begin_type? ? body.children : body
-
-          expression.is_a?(Array) ? expression.last : expression
-        end
-
-        # This class tracks variable assignments in a method body
-        # and if a variable contains object passed as argument at the end of
-        # the method.
-        class MethodVariableTracker
-          def initialize(body_node)
-            @body_node = body_node
-            @local = nil
-          end
-
-          def contain_local_object?(variable_name)
-            return @local[variable_name] if @local
-
-            @local = {}
-
-            scan(@body_node) { |node| process_assignment_node(node) }
-
-            @local[variable_name]
-          end
-
-          def scan(node, &block)
-            catch(:skip_children) do
-              yield node
-
-              node.each_child_node { |child_node| scan(child_node, &block) }
-            end
-          end
-
-          def process_assignment_node(node)
-            case node.type
-            when :masgn
-              process_multiple_assignment(node)
-            when :or_asgn, :and_asgn
-              process_logical_operator_assignment(node)
-            when :op_asgn
-              process_binary_operator_assignment(node)
-            when *ASSIGNMENT_TYPES
-              _, rhs_node = *node
-              process_assignment(node, rhs_node) if rhs_node
-            end
-          end
-
-          def process_multiple_assignment(masgn_node)
-            mlhs_node, mrhs_node = *masgn_node
-
-            mlhs_node.children.each_with_index do |lhs_node, index|
-              next unless ASSIGNMENT_TYPES.include?(lhs_node.type)
-
-              lhs_variable_name, = *lhs_node
-              rhs_node = mrhs_node.children[index]
-
-              if mrhs_node.array_type? && rhs_node
-                process_assignment(lhs_variable_name, rhs_node)
-              else
-                @local[lhs_variable_name] = true
-              end
-            end
-
-            throw :skip_children
-          end
-
-          def process_logical_operator_assignment(asgn_node)
-            lhs_node, rhs_node = *asgn_node
-            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
-
-            process_assignment(lhs_node, rhs_node)
-
-            throw :skip_children
-          end
-
-          def process_binary_operator_assignment(op_asgn_node)
-            lhs_node, = *op_asgn_node
-            return unless ASSIGNMENT_TYPES.include?(lhs_node.type)
-
-            lhs_variable_name, = *lhs_node
-            @local[lhs_variable_name] = true
-
-            throw :skip_children
-          end
-
-          def process_assignment(asgn_node, rhs_node)
-            lhs_variable_name, = *asgn_node
-
-            @local[lhs_variable_name] = if rhs_node.variable?
-                                          rhs_variable_name, = *rhs_node
-                                          @local[rhs_variable_name]
-                                        else
-                                          constructor?(rhs_node)
-                                        end
-          end
-
-          def constructor?(node)
-            return true if node.literal?
-            return false unless node.send_type?
-
-            node.method?(:new)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rubocop-1.26.0/lib/rubocop/cop/lint/useless_times.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for uses of `Integer#times` that will never yield
-      # (when the integer <= 0) or that will only ever yield once
-      # (`1.times`).
-      #
-      # @safety
-      #   This cop is unsafe as `times` returns its receiver, which is
-      #   *usually* OK, but might change behavior.
-      #
-      # @example
-      #   # bad
-      #   -5.times { do_something }
-      #   0.times { do_something }
-      #   1.times { do_something  }
-      #   1.times { |i| do_something(i) }
-      #
-      #   # good
-      #   do_something
-      #   do_something(1)
-      class UselessTimes < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Useless call to `%<count>i.times` detected.'
-        RESTRICT_ON_SEND = %i[times].freeze
-
-        # @!method times_call?(node)
-        def_node_matcher :times_call?, <<~PATTERN
-          (send (int $_) :times (block-pass (sym $_))?)
-        PATTERN
-
-        # @!method block_arg(node)
-        def_node_matcher :block_arg, <<~PATTERN
-          (block _ (args (arg $_)) ...)
-        PATTERN
-
-        # @!method block_reassigns_arg?(node)
-        def_node_search :block_reassigns_arg?, <<~PATTERN
-          (lvasgn %)
-        PATTERN
-
-        def on_send(node)
-          return unless (count, proc_name = times_call?(node))
-          return if count > 1
-
-          # Get the block node if applicable
-          node = node.block_node if node.block_literal?
-
-          add_offense(node, message: format(MSG, count: count)) do |corrector|
-            next if !own_line?(node) || node.parent&.send_type?
-
-            autocorrect(corrector, count, node, proc_name)
-          end
-        end
-
-        private
-
-        def autocorrect(corrector, count, node, proc_name)
-          if never_process?(count, node)
-            remove_node(corrector, node)
-          elsif !proc_name.empty?
-            autocorrect_block_pass(corrector, node, proc_name)
-          else
-            autocorrect_block(corrector, node)
-          end
-        end
-
-        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
-
-        def autocorrect_block_pass(corrector, node, proc_name)
-          corrector.replace(node, proc_name)
-        end
-
-        def autocorrect_block(corrector, node)
-          block_arg = block_arg(node)
-          return if block_reassigns_arg?(node, block_arg)
-
-          source = node.body.source
-          source.gsub!(/\b#{block_arg}\b/, '0') if block_arg
-
-          corrector.replace(node, fix_indentation(source, node.loc.column...node.body.loc.column))
-        end
-
-        def fix_indentation(source, range)
-          # Cleanup indentation in a multiline block
-          source_lines = source.split("\n")
-
-          source_lines[1..-1].each do |line|
-            next if line.empty?
-
-            line[range] = ''
-          end
-          source_lines.join("\n")
-        end
-
-        def own_line?(node)
-          # If there is anything else on the line other than whitespace,
-          # don't try to autocorrect
-          processed_source.buffer.source_line(node.loc.line)[0...node.loc.column] !~ /\S/
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rubocop-1.26.0/lib/rubocop/cop/lint/void.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for operators, variables, literals, and nonmutating
-      # methods used in void context.
-      #
-      # @example CheckForMethodsWithNoSideEffects: false (default)
-      #   # bad
-      #   def some_method
-      #     some_num * 10
-      #     do_something
-      #   end
-      #
-      #   def some_method(some_var)
-      #     some_var
-      #     do_something
-      #   end
-      #
-      # @example CheckForMethodsWithNoSideEffects: true
-      #   # bad
-      #   def some_method(some_array)
-      #     some_array.sort
-      #     do_something(some_array)
-      #   end
-      #
-      #   # good
-      #   def some_method
-      #     do_something
-      #     some_num * 10
-      #   end
-      #
-      #   def some_method(some_var)
-      #     do_something
-      #     some_var
-      #   end
-      #
-      #   def some_method(some_array)
-      #     some_array.sort!
-      #     do_something(some_array)
-      #   end
-      class Void < Base
-        OP_MSG = 'Operator `%<op>s` used in void context.'
-        VAR_MSG = 'Variable `%<var>s` used in void context.'
-        LIT_MSG = 'Literal `%<lit>s` used in void context.'
-        SELF_MSG = '`self` used in void context.'
-        DEFINED_MSG = '`%<defined>s` used in void context.'
-        NONMUTATING_MSG = 'Method `#%<method>s` used in void context. Did you mean `#%<method>s!`?'
-
-        BINARY_OPERATORS = %i[* / % + - == === != < > <= >= <=>].freeze
-        UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
-        OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
-        VOID_CONTEXT_TYPES = %i[def for block].freeze
-        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact
-                                 delete_prefix delete_suffix downcase
-                                 encode flatten gsub lstrip map merge next
-                                 reject reverse rotate rstrip scrub select
-                                 shuffle slice sort sort_by squeeze strip sub
-                                 succ swapcase tr tr_s transform_values
-                                 unicode_normalize uniq upcase].freeze
-
-        def on_block(node)
-          return unless node.body && !node.body.begin_type?
-          return unless in_void_context?(node.body)
-
-          check_expression(node.body)
-        end
-
-        def on_begin(node)
-          check_begin(node)
-        end
-        alias on_kwbegin on_begin
-
-        private
-
-        def check_begin(node)
-          expressions = *node
-          expressions.pop unless in_void_context?(node)
-          expressions.each { |expr| check_expression(expr) }
-        end
-
-        def check_expression(expr)
-          check_void_op(expr)
-          check_literal(expr)
-          check_var(expr)
-          check_self(expr)
-          check_defined(expr)
-          return unless cop_config['CheckForMethodsWithNoSideEffects']
-
-          check_nonmutating(expr)
-        end
-
-        def check_void_op(node)
-          return unless node.send_type? && OPERATORS.include?(node.method_name)
-
-          add_offense(node.loc.selector, message: format(OP_MSG, op: node.method_name))
-        end
-
-        def check_var(node)
-          return unless node.variable? || node.const_type?
-
-          add_offense(node.loc.name, message: format(VAR_MSG, var: node.loc.name.source))
-        end
-
-        def check_literal(node)
-          return if !node.literal? || node.xstr_type? || node.range_type?
-
-          add_offense(node, message: format(LIT_MSG, lit: node.source))
-        end
-
-        def check_self(node)
-          return unless node.self_type?
-
-          add_offense(node, message: SELF_MSG)
-        end
-
-        def check_defined(node)
-          return unless node.defined_type?
-
-          add_offense(node, message: format(DEFINED_MSG, defined: node.source))
-        end
-
-        def check_nonmutating(node)
-          return unless node.send_type? && NONMUTATING_METHODS.include?(node.method_name)
-
-          add_offense(node, message: format(NONMUTATING_MSG, method: node.method_name))
-        end
-
-        def in_void_context?(node)
-          parent = node.parent
-
-          return false unless parent && parent.children.last == node
-
-          VOID_CONTEXT_TYPES.include?(parent.type) && parent.void_context?
-        end
-      end
-    end
-  end
-end