op_connect 0.1.2 → 0.1.3

data/vendor/bundle/ruby/3.1.0/gems/rubocop-1.26.0/lib/rubocop/cop/style/word_array.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop can check for array literals made up of word-like
-      # strings, that are not using the %w() syntax.
-      #
-      # Alternatively, it can check for uses of the %w() syntax, in projects
-      # which do not want to include that syntax.
-      #
-      # NOTE: When using the `percent` style, %w() arrays containing a space
-      # will be registered as offenses.
-      #
-      # Configuration option: MinSize
-      # If set, arrays with fewer elements than this value will not trigger the
-      # cop. For example, a `MinSize` of `3` will not enforce a style on an
-      # array of 2 or fewer elements.
-      #
-      # @example EnforcedStyle: percent (default)
-      #   # good
-      #   %w[foo bar baz]
-      #
-      #   # bad
-      #   ['foo', 'bar', 'baz']
-      #
-      #   # bad (contains spaces)
-      #   %w[foo\ bar baz\ quux]
-      #
-      # @example EnforcedStyle: brackets
-      #   # good
-      #   ['foo', 'bar', 'baz']
-      #
-      #   # bad
-      #   %w[foo bar baz]
-      #
-      #   # good (contains spaces)
-      #   ['foo bar', 'baz quux']
-      class WordArray < Base
-        include ArrayMinSize
-        include ArraySyntax
-        include ConfigurableEnforcedStyle
-        include PercentArray
-        extend AutoCorrector
-
-        PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'
-        ARRAY_MSG = 'Use `%<prefer>s` for an array of words.'
-
-        class << self
-          attr_accessor :largest_brackets
-        end
-
-        def on_array(node)
-          if bracketed_array_of?(:str, node)
-            return if complex_content?(node.values)
-
-            check_bracketed_array(node, 'w')
-          elsif node.percent_literal?(:string)
-            check_percent_array(node)
-          end
-        end
-
-        private
-
-        def complex_content?(strings, complex_regex: word_regex)
-          strings.any? do |s|
-            next unless s.str_content
-
-            string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
-            !string.valid_encoding? ||
-              (complex_regex && !complex_regex.match?(string)) ||
-              / /.match?(string)
-          end
-        end
-
-        def invalid_percent_array_contents?(node)
-          # Disallow %w() arrays that contain invalid encoding or spaces
-          complex_content?(node.values, complex_regex: false)
-        end
-
-        def word_regex
-          Regexp.new(cop_config['WordRegex'])
-        end
-
-        def build_bracketed_array(node)
-          words = node.children.map do |word|
-            if word.dstr_type?
-              string_literal = to_string_literal(word.source)
-
-              trim_string_interporation_escape_character(string_literal)
-            else
-              to_string_literal(word.children[0])
-            end
-          end
-
-          "[#{words.join(', ')}]"
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rubocop-1.26.0/lib/rubocop/cop/style/yoda_condition.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop can either enforce or forbid Yoda conditions,
-      # i.e. comparison operations where the order of expression is reversed.
-      # eg. `5 == x`
-      #
-      # @safety
-      #   This cop is unsafe because comparison operators can be defined
-      #   differently on different classes, and are not guaranteed to
-      #   have the same result if reversed.
-      #
-      #   For example:
-      #
-      #   [source,ruby]
-      #   ----
-      #   class MyKlass
-      #     def ==(other)
-      #       true
-      #     end
-      #   end
-      #
-      #   obj = MyKlass.new
-      #   obj == 'string'   #=> true
-      #   'string' == obj   #=> false
-      #   ----
-      #
-      # @example EnforcedStyle: forbid_for_all_comparison_operators (default)
-      #   # bad
-      #   99 == foo
-      #   "bar" != foo
-      #   42 >= foo
-      #   10 < bar
-      #
-      #   # good
-      #   foo == 99
-      #   foo == "bar"
-      #   foo <= 42
-      #   bar > 10
-      #   "#{interpolation}" == foo
-      #   /#{interpolation}/ == foo
-      #
-      # @example EnforcedStyle: forbid_for_equality_operators_only
-      #   # bad
-      #   99 == foo
-      #   "bar" != foo
-      #
-      #   # good
-      #   99 >= foo
-      #   3 < a && a < 5
-      #
-      # @example EnforcedStyle: require_for_all_comparison_operators
-      #   # bad
-      #   foo == 99
-      #   foo == "bar"
-      #   foo <= 42
-      #   bar > 10
-      #
-      #   # good
-      #   99 == foo
-      #   "bar" != foo
-      #   42 >= foo
-      #   10 < bar
-      #
-      # @example EnforcedStyle: require_for_equality_operators_only
-      #   # bad
-      #   99 >= foo
-      #   3 < a && a < 5
-      #
-      #   # good
-      #   99 == foo
-      #   "bar" != foo
-      class YodaCondition < Base
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Reverse the order of the operands `%<source>s`.'
-        REVERSE_COMPARISON = { '<' => '>', '<=' => '>=', '>' => '<', '>=' => '<=' }.freeze
-        EQUALITY_OPERATORS = %i[== !=].freeze
-        NONCOMMUTATIVE_OPERATORS = %i[===].freeze
-        PROGRAM_NAMES = %i[$0 $PROGRAM_NAME].freeze
-        RESTRICT_ON_SEND = RuboCop::AST::Node::COMPARISON_OPERATORS
-
-        # @!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
-
-        def on_send(node)
-          return unless yoda_compatible_condition?(node)
-          return if (equality_only? && non_equality_operator?(node)) ||
-                    file_constant_equal_program_name?(node)
-
-          valid_yoda?(node) || add_offense(node) do |corrector|
-            corrector.replace(actual_code_range(node), corrected_code(node))
-          end
-        end
-
-        private
-
-        def enforce_yoda?
-          style == :require_for_all_comparison_operators ||
-            style == :require_for_equality_operators_only
-        end
-
-        def equality_only?
-          style == :forbid_for_equality_operators_only ||
-            style == :require_for_equality_operators_only
-        end
-
-        def yoda_compatible_condition?(node)
-          node.comparison_method? && !noncommutative_operator?(node)
-        end
-
-        def valid_yoda?(node)
-          lhs = node.receiver
-          rhs = node.first_argument
-
-          return true if (lhs.literal? && rhs.literal?) ||
-                         (!lhs.literal? && !rhs.literal?) ||
-                         interpolation?(lhs)
-
-          enforce_yoda? ? lhs.literal? : rhs.literal?
-        end
-
-        def message(node)
-          format(MSG, source: node.source)
-        end
-
-        def corrected_code(node)
-          lhs = node.receiver
-          rhs = node.first_argument
-
-          "#{rhs.source} #{reverse_comparison(node.method_name)} #{lhs.source}"
-        end
-
-        def actual_code_range(node)
-          range_between(node.loc.expression.begin_pos, node.loc.expression.end_pos)
-        end
-
-        def reverse_comparison(operator)
-          REVERSE_COMPARISON.fetch(operator.to_s, operator)
-        end
-
-        def non_equality_operator?(node)
-          !EQUALITY_OPERATORS.include?(node.method_name)
-        end
-
-        def noncommutative_operator?(node)
-          NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
-        end
-
-        def source_file_path_constant?(node)
-          node.source == '__FILE__'
-        end
-
-        def program_name?(name)
-          PROGRAM_NAMES.include?(name)
-        end
-
-        def interpolation?(node)
-          return true if node.dstr_type?
-
-          node.regexp_type? && node.interpolation?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.1.0/gems/rubocop-1.26.0/lib/rubocop/cop/style/zero_length_predicate.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for numeric comparisons that can be replaced
-      # by a predicate method, such as receiver.length == 0,
-      # receiver.length > 0, receiver.length != 0,
-      # receiver.length < 1 and receiver.size == 0 that can be
-      # replaced by receiver.empty? and !receiver.empty?.
-      #
-      # @safety
-      #   This cop is unsafe because it cannot be guaranteed that the receiver
-      #   has an `empty?` method that is defined in terms of `length`. If there
-      #   is a non-standard class that redefines `length` or `empty?`, the cop
-      #   may register a false positive.
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3].length == 0
-      #   0 == "foobar".length
-      #   array.length < 1
-      #   {a: 1, b: 2}.length != 0
-      #   string.length > 0
-      #   hash.size > 0
-      #
-      #   # good
-      #   [1, 2, 3].empty?
-      #   "foobar".empty?
-      #   array.empty?
-      #   !{a: 1, b: 2}.empty?
-      #   !string.empty?
-      #   !hash.empty?
-      class ZeroLengthPredicate < Base
-        extend AutoCorrector
-
-        ZERO_MSG = 'Use `empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
-        NONZERO_MSG = 'Use `!empty?` instead of `%<lhs>s %<opr>s %<rhs>s`.'
-
-        RESTRICT_ON_SEND = %i[size length].freeze
-
-        def on_send(node)
-          check_zero_length_predicate(node)
-          check_nonzero_length_predicate(node)
-        end
-
-        private
-
-        def check_zero_length_predicate(node)
-          zero_length_predicate = zero_length_predicate(node.parent)
-          return unless zero_length_predicate
-
-          lhs, opr, rhs = zero_length_predicate
-
-          return if non_polymorphic_collection?(node.parent)
-
-          add_offense(
-            node.parent, message: format(ZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
-          ) do |corrector|
-            corrector.replace(node.parent, replacement(node.parent))
-          end
-        end
-
-        def check_nonzero_length_predicate(node)
-          nonzero_length_predicate = nonzero_length_predicate(node.parent)
-          return unless nonzero_length_predicate
-
-          lhs, opr, rhs = nonzero_length_predicate
-
-          return if non_polymorphic_collection?(node.parent)
-
-          add_offense(
-            node.parent, message: format(NONZERO_MSG, lhs: lhs, opr: opr, rhs: rhs)
-          ) do |corrector|
-            corrector.replace(node.parent, replacement(node.parent))
-          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}))
-           (send (send (...) ${:length :size}) $:<  (int $1))
-           (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}))}
-        PATTERN
-
-        def replacement(node)
-          receiver = zero_length_receiver(node)
-          return "#{receiver.source}.empty?" if receiver
-
-          "!#{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 $_ _))
-           (send (send $_ _) :<  (int 1))
-           (send (int 1) :> (send $_ _))}
-        PATTERN
-
-        # @!method other_receiver(node)
-        def_node_matcher :other_receiver, <<~PATTERN
-          {(send (send $_ _) _ _)
-           (send _ _ (send $_ _))}
-        PATTERN
-
-        # 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} ...) ...) ...)}
-        PATTERN
-      end
-    end
-  end
-end

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

@@ -1,259 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # A group of cops, ready to be called on duty to inspect files.
-    # Team is responsible for selecting only relevant cops to be sent on duty,
-    # as well as insuring that the needed forces are sent along with them.
-    #
-    # For performance reasons, Team will first dispatch cops & forces in two groups,
-    # first the ones needed for autocorrection (if any), then the rest
-    # (unless autocorrections happened).
-    class Team
-      attr_reader :errors, :warnings, :updated_source_file, :cops
-
-      alias updated_source_file? updated_source_file
-
-      def initialize(cops, config = nil, options = {})
-        @cops = cops
-        @config = config
-        @options = options
-        reset
-        @ready = true
-
-        validate_config
-      end
-
-      # @return [Team]
-      def self.new(cop_or_classes, config, options = {})
-        # Support v0 api:
-        return mobilize(cop_or_classes, config, options) if cop_or_classes.first.is_a?(Class)
-
-        super
-      end
-
-      # @return [Team] with cops assembled from the given `cop_classes`
-      def self.mobilize(cop_classes, config, options = {})
-        cops = mobilize_cops(cop_classes, config, options)
-        new(cops, config, options)
-      end
-
-      # @return [Array<Cop::Cop>]
-      def self.mobilize_cops(cop_classes, config, options = {})
-        cop_classes = Registry.new(cop_classes.to_a) unless cop_classes.is_a?(Registry)
-        only = options.fetch(:only, [])
-        safe = options.fetch(:safe, false)
-        cop_classes.enabled(config, only, only_safe: safe).map do |cop_class|
-          cop_class.new(config, options)
-        end
-      end
-
-      def autocorrect?
-        @options[:auto_correct]
-      end
-
-      def debug?
-        @options[:debug]
-      end
-
-      # @deprecated. Use investigate
-      # @return Array<offenses>
-      def inspect_file(processed_source)
-        investigate(processed_source).offenses
-      end
-
-      # @return [Commissioner::InvestigationReport]
-      def investigate(processed_source)
-        be_ready
-
-        # The autocorrection process may have to be repeated multiple times
-        # until there are no corrections left to perform
-        # To speed things up, run auto-correcting cops by themselves, and only
-        # run the other cops when no corrections are left
-        on_duty = roundup_relevant_cops(processed_source.file_path)
-
-        autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
-
-        report = investigate_partial(autocorrect_cops, processed_source)
-
-        unless autocorrect(processed_source, report)
-          # If we corrected some errors, another round of inspection will be
-          # done, and any other offenses will be caught then, so only need
-          # to check other_cops if no correction was done
-          report = report.merge(investigate_partial(other_cops, processed_source))
-        end
-
-        process_errors(processed_source.path, report.errors)
-
-        report
-      ensure
-        @ready = false
-      end
-
-      # @deprecated
-      def forces
-        @forces ||= self.class.forces_for(cops)
-      end
-
-      # @return [Array<Force>] needed for the given cops
-      def self.forces_for(cops)
-        needed = Hash.new { |h, k| h[k] = [] }
-        cops.each do |cop|
-          forces = cop.class.joining_forces
-          if forces.is_a?(Array)
-            forces.each { |force| needed[force] << cop }
-          elsif forces
-            needed[forces] << cop
-          end
-        end
-
-        needed.map { |force_class, joining_cops| force_class.new(joining_cops) }
-      end
-
-      def external_dependency_checksum
-        keys = cops.map(&:external_dependency_checksum).compact
-        Digest::SHA1.hexdigest(keys.join)
-      end
-
-      private
-
-      def autocorrect(processed_source, report)
-        @updated_source_file = false
-        return unless autocorrect?
-        return if report.processed_source.parser_error
-
-        new_source = autocorrect_report(report)
-
-        return unless new_source
-
-        if @options[:stdin]
-          # holds source read in from stdin, when --stdin option is used
-          @options[:stdin] = new_source
-        else
-          filename = processed_source.buffer.name
-          File.write(filename, new_source)
-        end
-        @updated_source_file = true
-      end
-
-      def be_ready
-        return if @ready
-
-        reset
-        @cops.map!(&:ready)
-        @ready = true
-      end
-
-      def reset
-        @errors = []
-        @warnings = []
-      end
-
-      # @return [Commissioner::InvestigationReport]
-      def investigate_partial(cops, processed_source)
-        commissioner = Commissioner.new(cops, self.class.forces_for(cops), @options)
-        commissioner.investigate(processed_source)
-      end
-
-      # @return [Array<cop>]
-      def roundup_relevant_cops(filename)
-        cops.reject do |cop|
-          cop.excluded_file?(filename) ||
-            !support_target_ruby_version?(cop) ||
-            !support_target_rails_version?(cop)
-        end
-      end
-
-      def support_target_ruby_version?(cop)
-        return true unless cop.class.respond_to?(:support_target_ruby_version?)
-
-        cop.class.support_target_ruby_version?(cop.target_ruby_version)
-      end
-
-      def support_target_rails_version?(cop)
-        return true unless cop.class.respond_to?(:support_target_rails_version?)
-
-        cop.class.support_target_rails_version?(cop.target_rails_version)
-      end
-
-      def autocorrect_report(report)
-        corrector = collate_corrections(report)
-
-        corrector.rewrite unless corrector.empty?
-      end
-
-      def collate_corrections(report)
-        corrector = Corrector.new(report.processed_source)
-
-        each_corrector(report) do |to_merge|
-          suppress_clobbering do
-            corrector.merge!(to_merge)
-          end
-        end
-
-        corrector
-      end
-
-      def each_corrector(report)
-        skips = Set.new
-        report.cop_reports.each do |cop_report|
-          cop = cop_report.cop
-          corrector = cop_report.corrector
-
-          next if corrector.nil? || corrector.empty?
-          next if skips.include?(cop.class)
-
-          yield corrector
-
-          skips.merge(cop.class.autocorrect_incompatible_with)
-        end
-      end
-
-      def suppress_clobbering
-        yield
-      rescue ::Parser::ClobberingError
-        # ignore Clobbering errors
-      end
-
-      def validate_config
-        cops.each do |cop|
-          cop.validate_config if cop.respond_to?(:validate_config)
-        end
-      end
-
-      def process_errors(file, errors)
-        errors.each do |error|
-          line = ":#{error.line}" if error.line
-          column = ":#{error.column}" if error.column
-          location = "#{file}#{line}#{column}"
-          cause = error.cause
-
-          if cause.is_a?(Warning)
-            handle_warning(cause, location)
-          else
-            handle_error(cause, location, error.cop)
-          end
-        end
-      end
-
-      def handle_warning(error, location)
-        message = Rainbow("#{error.message} (from file: #{location})").yellow
-
-        @warnings << message
-        warn message
-        puts error.backtrace if debug?
-      end
-
-      def handle_error(error, location, cop)
-        message = Rainbow("An error occurred while #{cop.name} cop was inspecting #{location}.").red
-        @errors << message
-        warn message
-        if debug?
-          puts error.message, error.backtrace
-        else
-          warn 'To see the complete backtrace run rubocop -d.'
-        end
-      end
-    end
-  end
-end