primary_connect_proto 0.20.0 → 0.22.0

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/class_and_module_children.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks the style of children definitions at classes and
-      # modules. Basically there are two different styles:
-      #
-      # @example EnforcedStyle: nested (default)
-      #   # good
-      #   # have each child on its own line
-      #   class Foo
-      #     class Bar
-      #     end
-      #   end
-      #
-      # @example EnforcedStyle: compact
-      #   # good
-      #   # combine definitions as much as possible
-      #   class Foo::Bar
-      #   end
-      #
-      # The compact style is only forced for classes/modules with one child.
-      class ClassAndModuleChildren < Cop
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-
-        NESTED_MSG = 'Use nested module/class definitions instead of ' \
-                     'compact style.'.freeze
-        COMPACT_MSG = 'Use compact module/class definition instead of ' \
-                      'nested style.'.freeze
-
-        def on_class(node)
-          _name, superclass, body = *node
-          return if superclass && style != :nested
-
-          check_style(node, body)
-        end
-
-        def on_module(node)
-          _name, body = *node
-          check_style(node, body)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.class_type?
-              name, superclass, body = *node
-              return if superclass && style != :nested
-            else
-              name, body = *node
-            end
-            nest_or_compact(corrector, node, name, body)
-          end
-        end
-
-        private
-
-        def nest_or_compact(corrector, node, name, body)
-          if style == :nested
-            nest_definition(corrector, node)
-          else
-            compact_definition(corrector, node, name, body)
-          end
-        end
-
-        def nest_definition(corrector, node)
-          padding = ((' ' * indent_width) + leading_spaces(node)).to_s
-          padding_for_trailing_end = padding.sub(' ' * node.loc.end.column, '')
-
-          replace_keyword_with_module(corrector, node)
-          split_on_double_colon(corrector, node, padding)
-          add_trailing_end(corrector, node, padding_for_trailing_end)
-        end
-
-        def replace_keyword_with_module(corrector, node)
-          corrector.replace(node.loc.keyword, 'module'.freeze)
-        end
-
-        def split_on_double_colon(corrector, node, padding)
-          children_definition = node.children.first
-          range = range_between(children_definition.loc.double_colon.begin_pos,
-                                children_definition.loc.double_colon.end_pos)
-          replacement = "\n#{padding}#{node.loc.keyword.source} ".freeze
-
-          corrector.replace(range, replacement)
-        end
-
-        def add_trailing_end(corrector, node, padding)
-          replacement = "#{padding}end\n#{leading_spaces(node)}end".freeze
-          corrector.replace(node.loc.end, replacement)
-        end
-
-        def compact_definition(corrector, node, name, body)
-          compact_node(corrector, node, name, body)
-          remove_end(corrector, body)
-        end
-
-        def compact_node(corrector, node, name, body)
-          const_name = "#{name.const_name}::#{body.children.first.const_name}"
-          replacement = "#{body.type} #{const_name}"
-          range = range_between(node.loc.keyword.begin_pos,
-                                body.loc.name.end_pos)
-          corrector.replace(range, replacement)
-        end
-
-        def remove_end(corrector, body)
-          range = range_between(
-            body.loc.end.begin_pos - leading_spaces(body).size,
-            body.loc.end.end_pos + 1
-          )
-          corrector.remove(range)
-        end
-
-        def leading_spaces(node)
-          node.source_range.source_line[/\A\s*/]
-        end
-
-        def indent_width
-          @config.for_cop('IndentationWidth')['Width'] || 2
-        end
-
-        def check_style(node, body)
-          if style == :nested
-            check_nested_style(node)
-          else
-            check_compact_style(node, body)
-          end
-        end
-
-        def check_nested_style(node)
-          return unless compact_node_name?(node)
-
-          add_offense(node, location: :name, message: NESTED_MSG)
-        end
-
-        def check_compact_style(node, body)
-          return unless one_child?(body) && !compact_node_name?(node)
-
-          add_offense(node, location: :name, message: COMPACT_MSG)
-        end
-
-        def one_child?(body)
-          body && %i[module class].include?(body.type)
-        end
-
-        def compact_node_name?(node)
-          node.loc.name.source =~ /::/
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/class_check.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop enforces consistent use of `Object#is_a?` or `Object#kind_of?`.
-      #
-      # @example EnforcedStyle: is_a? (default)
-      #   # bad
-      #   var.kind_of?(Date)
-      #   var.kind_of?(Integer)
-      #
-      #   # good
-      #   var.is_a?(Date)
-      #   var.is_a?(Integer)
-      #
-      # @example EnforcedStyle: kind_of?
-      #   # bad
-      #   var.is_a?(Time)
-      #   var.is_a?(String)
-      #
-      #   # good
-      #   var.kind_of?(Time)
-      #   var.kind_of?(String)
-      #
-      class ClassCheck < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Prefer `Object#%<prefer>s` over `Object#%<current>s`.'.freeze
-
-        def_node_matcher :class_check?, '(send _ ${:is_a? :kind_of?} _)'
-
-        def on_send(node)
-          class_check?(node) do |method_name|
-            return if style == method_name
-
-            add_offense(node, location: :selector)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = node.method?(:is_a?) ? 'kind_of?' : 'is_a?'
-
-            corrector.replace(node.loc.selector, replacement)
-          end
-        end
-
-        def message(node)
-          if node.method?(:is_a?)
-            format(MSG, prefer: 'kind_of?', current: 'is_a?')
-          else
-            format(MSG, prefer: 'is_a?', current: 'kind_of?')
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/class_methods.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of the class/module name instead of
-      # self, when defining class/module methods.
-      #
-      # @example
-      #   # bad
-      #   class SomeClass
-      #     def SomeClass.class_method
-      #       # ...
-      #     end
-      #   end
-      #
-      #   # good
-      #   class SomeClass
-      #     def self.class_method
-      #       # ...
-      #     end
-      #   end
-      class ClassMethods < Cop
-        MSG = 'Use `self.%<method>s` instead of `%<class>s.%<method>s`.'.freeze
-
-        def on_class(node)
-          name, _superclass, body = *node
-          check(name, body)
-        end
-
-        def on_module(node)
-          name, body = *node
-          check(name, body)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.name, 'self') }
-        end
-
-        private
-
-        def check(name, node)
-          return unless node
-
-          if node.defs_type?
-            check_defs(name, node)
-          elsif node.begin_type?
-            node.each_child_node(:defs) { |n| check_defs(name, n) }
-          end
-        end
-
-        def check_defs(name, node)
-          definee, method_name, _args, _body = *node
-          # check if the class/module name matches the definee for the defs node
-          return unless name == definee
-
-          _, class_name = *definee
-          add_offense(definee, location: :name,
-                               message: message(class_name, method_name))
-        end
-
-        def message(class_name, method_name)
-          format(MSG, method: method_name, class: class_name)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/class_vars.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for uses of class variables. Offenses
-      # are signaled only on assignment to class variables to
-      # reduce the number of offenses that would be reported.
-      #
-      # You have to be careful when setting a value for a class
-      # variable; if a class has been inherited, changing the
-      # value of a class variable also affects the inheriting
-      # classes. This means that it's almost always better to
-      # use a class instance variable instead.
-      #
-      # @example
-      #   # bad
-      #   class A
-      #     @@test = 10
-      #   end
-      #
-      #   # good
-      #   class A
-      #     @test = 10
-      #   end
-      #
-      #   class A
-      #     def test
-      #       @@test # you can access class variable without offense
-      #     end
-      #   end
-      #
-      class ClassVars < Cop
-        MSG = 'Replace class var %<class_var>s with a class ' \
-              'instance var.'.freeze
-
-        def on_cvasgn(node)
-          add_offense(node, location: :name)
-        end
-
-        def message(node)
-          class_var, = *node
-          format(MSG, class_var: class_var)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/collection_methods.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop enforces the use of consistent method names
-      # from the Enumerable module.
-      #
-      # Unfortunately we cannot actually know if a method is from
-      # Enumerable or not (static analysis limitation), so this cop
-      # can yield some false positives.
-      #
-      # You can customize the mapping from undesired method to desired method.
-      #
-      # e.g. to use `detect` over `find`:
-      #
-      #   Style/CollectionMethods:
-      #     PreferredMethods:
-      #       find: detect
-      #
-      # The default mapping for `PreferredMethods` behaves as follows.
-      #
-      # @example
-      #   # bad
-      #   items.collect
-      #   items.collect!
-      #   items.inject
-      #   items.detect
-      #   items.find_all
-      #
-      #   # good
-      #   items.map
-      #   items.map!
-      #   items.reduce
-      #   items.find
-      #   items.select
-      #
-      class CollectionMethods < Cop
-        include MethodPreference
-
-        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'.freeze
-
-        def on_block(node)
-          check_method_node(node.send_node)
-        end
-
-        def on_send(node)
-          return unless node.arguments.one? &&
-                        node.first_argument.block_pass_type?
-
-          check_method_node(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source))
-          end
-        end
-
-        private
-
-        def message(node)
-          format(MSG,
-                 prefer: preferred_method(node.method_name),
-                 current: node.method_name)
-        end
-
-        def check_method_node(node)
-          return unless preferred_methods[node.method_name]
-
-          add_offense(node, location: :selector)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/colon_method_call.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for methods invoked via the :: operator instead
-      # of the . operator (like FileUtils::rmdir instead of FileUtils.rmdir).
-      #
-      # @example
-      #   # bad
-      #   Timeout::timeout(500) { do_something }
-      #   FileUtils::rmdir(dir)
-      #   Marshal::dump(obj)
-      #
-      #   # good
-      #   Timeout.timeout(500) { do_something }
-      #   FileUtils.rmdir(dir)
-      #   Marshal.dump(obj)
-      #
-      class ColonMethodCall < Cop
-        MSG = 'Do not use `::` for method calls.'.freeze
-
-        def_node_matcher :java_type_node?, <<-PATTERN
-          (send
-            (const nil? :Java) _)
-        PATTERN
-
-        def self.autocorrect_incompatible_with
-          [RedundantSelf]
-        end
-
-        def on_send(node)
-          # ignore Java interop code like Java::int
-          return if java_type_node?(node)
-
-          return unless node.receiver && node.double_colon?
-          return if node.camel_case_method?
-
-          add_offense(node, location: :dot)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.dot, '.') }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/colon_method_definition.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for class methods that are defined using the `::`
-      # operator instead of the `.` operator.
-      #
-      # @example
-      #   # bad
-      #   class Foo
-      #     def self::bar
-      #     end
-      #   end
-      #
-      #   # good
-      #   class Foo
-      #     def self.bar
-      #     end
-      #   end
-      #
-      class ColonMethodDefinition < Cop
-        MSG = 'Do not use `::` for defining class methods.'.freeze
-
-        def on_defs(node)
-          return unless node.loc.operator.source == '::'
-
-          add_offense(node, location: :operator)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.operator, '.') }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.0.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/command_literal.rb

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop enforces using `` or %x around command literals.
-      #
-      # @example EnforcedStyle: backticks (default)
-      #   # bad
-      #   folders = %x(find . -type d).split
-      #
-      #   # bad
-      #   %x(
-      #     ln -s foo.example.yml foo.example
-      #     ln -s bar.example.yml bar.example
-      #   )
-      #
-      #   # good
-      #   folders = `find . -type d`.split
-      #
-      #   # good
-      #   `
-      #     ln -s foo.example.yml foo.example
-      #     ln -s bar.example.yml bar.example
-      #   `
-      #
-      # @example EnforcedStyle: mixed
-      #   # bad
-      #   folders = %x(find . -type d).split
-      #
-      #   # bad
-      #   `
-      #     ln -s foo.example.yml foo.example
-      #     ln -s bar.example.yml bar.example
-      #   `
-      #
-      #   # good
-      #   folders = `find . -type d`.split
-      #
-      #   # good
-      #   %x(
-      #     ln -s foo.example.yml foo.example
-      #     ln -s bar.example.yml bar.example
-      #   )
-      #
-      # @example EnforcedStyle: percent_x
-      #   # bad
-      #   folders = `find . -type d`.split
-      #
-      #   # bad
-      #   `
-      #     ln -s foo.example.yml foo.example
-      #     ln -s bar.example.yml bar.example
-      #   `
-      #
-      #   # good
-      #   folders = %x(find . -type d).split
-      #
-      #   # good
-      #   %x(
-      #     ln -s foo.example.yml foo.example
-      #     ln -s bar.example.yml bar.example
-      #   )
-      #
-      # @example AllowInnerBackticks: false (default)
-      #   # If `false`, the cop will always recommend using `%x` if one or more
-      #   # backticks are found in the command string.
-      #
-      #   # bad
-      #   `echo \`ls\``
-      #
-      #   # good
-      #   %x(echo `ls`)
-      #
-      # @example AllowInnerBackticks: true
-      #   # good
-      #   `echo \`ls\``
-      class CommandLiteral < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG_USE_BACKTICKS = 'Use backticks around command string.'.freeze
-        MSG_USE_PERCENT_X = 'Use `%x` around command string.'.freeze
-
-        def on_xstr(node)
-          return if node.heredoc?
-
-          if backtick_literal?(node)
-            check_backtick_literal(node)
-          else
-            check_percent_x_literal(node)
-          end
-        end
-
-        def autocorrect(node)
-          return if contains_backtick?(node)
-
-          replacement = if backtick_literal?(node)
-                          ['%x', ''].zip(preferred_delimiter).map(&:join)
-                        else
-                          %w[` `]
-                        end
-
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
-          end
-        end
-
-        private
-
-        def check_backtick_literal(node)
-          return if allowed_backtick_literal?(node)
-
-          add_offense(node)
-        end
-
-        def check_percent_x_literal(node)
-          return if allowed_percent_x_literal?(node)
-
-          add_offense(node)
-        end
-
-        def message(node)
-          backtick_literal?(node) ? MSG_USE_PERCENT_X : MSG_USE_BACKTICKS
-        end
-
-        def allowed_backtick_literal?(node)
-          case style
-          when :backticks
-            !contains_disallowed_backtick?(node)
-          when :mixed
-            node.single_line? && !contains_disallowed_backtick?(node)
-          end
-        end
-
-        def allowed_percent_x_literal?(node)
-          case style
-          when :backticks
-            contains_disallowed_backtick?(node)
-          when :mixed
-            node.multiline? || contains_disallowed_backtick?(node)
-          when :percent_x
-            true
-          end
-        end
-
-        def contains_disallowed_backtick?(node)
-          !allow_inner_backticks? && contains_backtick?(node)
-        end
-
-        def allow_inner_backticks?
-          cop_config['AllowInnerBackticks']
-        end
-
-        def contains_backtick?(node)
-          node_body(node) =~ /`/
-        end
-
-        def node_body(node)
-          loc = node.loc
-          loc.expression.source[loc.begin.length...-loc.end.length]
-        end
-
-        def backtick_literal?(node)
-          node.loc.begin.source == '`'
-        end
-
-        def preferred_delimiter
-          (command_delimiter || default_delimiter).split(//)
-        end
-
-        def command_delimiter
-          preferred_delimiters_config['%x']
-        end
-
-        def default_delimiter
-          preferred_delimiters_config['default']
-        end
-
-        def preferred_delimiters_config
-          config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']
-        end
-      end
-    end
-  end
-end