primary_connect_proto 0.1.0 → 0.5.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/min_max.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for potential uses of `Enumerable#minmax`.
-      #
-      # @example
-      #
-      #   # bad
-      #   bar = [foo.min, foo.max]
-      #   return foo.min, foo.max
-      #
-      #   # good
-      #   bar = foo.minmax
-      #   return foo.minmax
-      class MinMax < Cop
-        MSG = 'Use `%<receiver>s.minmax` instead of `%<offender>s`.'.freeze
-
-        def on_array(node)
-          min_max_candidate(node) do |receiver|
-            offender = offending_range(node)
-
-            add_offense(node, location: offender,
-                              message: message(offender, receiver))
-          end
-        end
-        alias on_return on_array
-
-        def autocorrect(node)
-          receiver = node.children.first.receiver
-
-          lambda do |corrector|
-            corrector.replace(offending_range(node),
-                              "#{receiver.source}.minmax")
-          end
-        end
-
-        private
-
-        def_node_matcher :min_max_candidate, <<-PATTERN
-          ({array return} (send [$_receiver !nil?] :min) (send [$_receiver !nil?] :max))
-        PATTERN
-
-        def message(offender, receiver)
-          format(MSG, offender: offender.source,
-                      receiver: receiver.source)
-        end
-
-        def offending_range(node)
-          case node.type
-          when :return
-            argument_range(node)
-          else
-            node.loc.expression
-          end
-        end
-
-        def argument_range(node)
-          first_argument_range = node.children.first.loc.expression
-          last_argument_range  = node.children.last.loc.expression
-
-          first_argument_range.join(last_argument_range)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/missing_else.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # Checks for `if` expressions that do not have an `else` branch.
-      #
-      # Supported styles are: if, case, both.
-      #
-      # @example EnforcedStyle: if
-      #   # warn when an `if` expression is missing an `else` branch.
-      #
-      #   # bad
-      #   if condition
-      #     statement
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   else
-      #     # the content of `else` branch will be determined by Style/EmptyElse
-      #   end
-      #
-      #   # good
-      #   case var
-      #   when condition
-      #     statement
-      #   end
-      #
-      #   # good
-      #   case var
-      #   when condition
-      #     statement
-      #   else
-      #     # the content of `else` branch will be determined by Style/EmptyElse
-      #   end
-      #
-      # @example EnforcedStyle: case
-      #   # warn when a `case` expression is missing an `else` branch.
-      #
-      #   # bad
-      #   case var
-      #   when condition
-      #     statement
-      #   end
-      #
-      #   # good
-      #   case var
-      #   when condition
-      #     statement
-      #   else
-      #     # the content of `else` branch will be determined by Style/EmptyElse
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   else
-      #     # the content of `else` branch will be determined by Style/EmptyElse
-      #   end
-      #
-      # @example EnforcedStyle: both (default)
-      #   # warn when an `if` or `case` expression is missing an `else` branch.
-      #
-      #   # bad
-      #   if condition
-      #     statement
-      #   end
-      #
-      #   # bad
-      #   case var
-      #   when condition
-      #     statement
-      #   end
-      #
-      #   # good
-      #   if condition
-      #     statement
-      #   else
-      #     # the content of `else` branch will be determined by Style/EmptyElse
-      #   end
-      #
-      #   # good
-      #   case var
-      #   when condition
-      #     statement
-      #   else
-      #     # the content of `else` branch will be determined by Style/EmptyElse
-      #   end
-      class MissingElse < Cop
-        include OnNormalIfUnless
-        include ConfigurableEnforcedStyle
-
-        MSG = '`%<type>s` condition requires an `else`-clause.'.freeze
-        MSG_NIL = '`%<type>s` condition requires an `else`-clause with ' \
-                  '`nil` in it.'.freeze
-        MSG_EMPTY = '`%<type>s` condition requires an empty ' \
-                    '`else`-clause.'.freeze
-
-        def on_normal_if_unless(node)
-          return if case_style?
-          return if unless_else_cop_enabled? && node.unless?
-
-          check(node)
-        end
-
-        def on_case(node)
-          return if if_style?
-
-          check(node)
-        end
-
-        private
-
-        def check(node)
-          return if node.else?
-
-          if empty_else_cop_enabled?
-            if empty_else_style == :empty
-              add_offense(node)
-            elsif empty_else_style == :nil
-              add_offense(node)
-            end
-          end
-
-          add_offense(node)
-        end
-
-        def message(node)
-          template = case empty_else_style
-                     when :empty
-                       MSG_NIL
-                     when :nil
-                       MSG_EMPTY
-                     else
-                       MSG
-                     end
-
-          format(template, type: node.type)
-        end
-
-        def if_style?
-          style == :if
-        end
-
-        def case_style?
-          style == :case
-        end
-
-        def unless_else_cop_enabled?
-          unless_else_config.fetch('Enabled')
-        end
-
-        def unless_else_config
-          config.for_cop('Style/UnlessElse')
-        end
-
-        def empty_else_cop_enabled?
-          empty_else_config.fetch('Enabled')
-        end
-
-        def empty_else_style
-          return unless empty_else_config.key?('EnforcedStyle')
-
-          empty_else_config['EnforcedStyle'].to_sym
-        end
-
-        def empty_else_config
-          config.for_cop('Style/EmptyElse')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/missing_respond_to_missing.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for the presence of `method_missing` without also
-      # defining `respond_to_missing?`.
-      #
-      # @example
-      #   #bad
-      #   def method_missing(name, *args)
-      #     # ...
-      #   end
-      #
-      #   #good
-      #   def respond_to_missing?(name, include_private)
-      #     # ...
-      #   end
-      #
-      #   def method_missing(name, *args)
-      #     # ...
-      #   end
-      #
-      class MissingRespondToMissing < Cop
-        MSG =
-          'When using `method_missing`, define `respond_to_missing?`.'.freeze
-
-        def on_def(node)
-          return unless node.method?(:method_missing)
-          return if implements_respond_to_missing?(node)
-
-          add_offense(node)
-        end
-        alias on_defs on_def
-
-        private
-
-        def implements_respond_to_missing?(node)
-          node.parent.each_child_node(node.type).any? do |sibling|
-            sibling.method?(:respond_to_missing?)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/mixin_grouping.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for grouping of mixins in `class` and `module` bodies.
-      # By default it enforces mixins to be placed in separate declarations,
-      # but it can be configured to enforce grouping them in one declaration.
-      #
-      # @example EnforcedStyle: separated (default)
-      #   # bad
-      #   class Foo
-      #     include Bar, Qox
-      #   end
-      #
-      #   # good
-      #   class Foo
-      #     include Qox
-      #     include Bar
-      #   end
-      #
-      # @example EnforcedStyle: grouped
-      #   # bad
-      #   class Foo
-      #     extend Bar
-      #     extend Qox
-      #   end
-      #
-      #   # good
-      #   class Foo
-      #     extend Qox, Bar
-      #   end
-      class MixinGrouping < Cop
-        include ConfigurableEnforcedStyle
-
-        MIXIN_METHODS = %i[extend include prepend].freeze
-        MSG = 'Put `%<mixin>s` mixins in %<suffix>s.'.freeze
-
-        def on_class(node)
-          begin_node = node.child_nodes.find(&:begin_type?) || node
-          begin_node.each_child_node(:send).select(&:macro?).each do |macro|
-            next unless MIXIN_METHODS.include?(macro.method_name)
-
-            check(macro)
-          end
-        end
-
-        alias on_module on_class
-
-        def autocorrect(node)
-          range = node.loc.expression
-          if separated_style?
-            correction = separate_mixins(node)
-          else
-            mixins = sibling_mixins(node)
-            if node == mixins.first
-              correction = group_mixins(node, mixins)
-            else
-              range = range_to_remove_for_subsequent_mixin(mixins, node)
-              correction = ''
-            end
-          end
-
-          ->(corrector) { corrector.replace(range, correction) }
-        end
-
-        private
-
-        def range_to_remove_for_subsequent_mixin(mixins, node)
-          range = node.loc.expression
-          prev_mixin = mixins.each_cons(2) { |m, n| break m if n == node }
-          between = prev_mixin.loc.expression.end
-                              .join(range.begin)
-          # if separated from previous mixin with only whitespace?
-          if between.source !~ /\S/
-            range = range.join(between) # then remove that too
-          end
-          range
-        end
-
-        def check(send_node)
-          if separated_style?
-            check_separated_style(send_node)
-          else
-            check_grouped_style(send_node)
-          end
-        end
-
-        def check_grouped_style(send_node)
-          return if sibling_mixins(send_node).size == 1
-
-          add_offense(send_node)
-        end
-
-        def check_separated_style(send_node)
-          return if send_node.arguments.one?
-
-          add_offense(send_node)
-        end
-
-        def sibling_mixins(send_node)
-          siblings = send_node.parent.each_child_node(:send)
-                              .select(&:macro?)
-
-          siblings.select do |sibling_node|
-            sibling_node.method_name == send_node.method_name
-          end
-        end
-
-        def message(send_node)
-          suffix =
-            separated_style? ? 'separate statements' : 'a single statement'
-
-          format(MSG, mixin: send_node.method_name, suffix: suffix)
-        end
-
-        def grouped_style?
-          style == :grouped
-        end
-
-        def separated_style?
-          style == :separated
-        end
-
-        def separate_mixins(node)
-          _receiver, mixin, *args = *node
-          args.reverse!
-          first_mixin = String.new("#{mixin} #{args.first.source}")
-
-          args[1..-1].inject(first_mixin) do |replacement, arg|
-            replacement << "\n#{indent(node)}#{mixin} #{arg.source}"
-          end
-        end
-
-        def group_mixins(node, mixins)
-          _receiver, mixin, *_args = *node
-          all_mixin_arguments = mixins.reverse.flat_map do |m|
-            m.arguments.map(&:source)
-          end
-
-          "#{mixin} #{all_mixin_arguments.join(', ')}"
-        end
-
-        def indent(node)
-          ' ' * node.loc.column
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/mixin_usage.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks that `include`, `extend` and `prepend` statements appear
-      # inside classes and modules, not at the top level, so as to not affect
-      # the behavior of `Object`.
-      #
-      # @example
-      #   # bad
-      #   include M
-      #
-      #   class C
-      #   end
-      #
-      #   # bad
-      #   extend M
-      #
-      #   class C
-      #   end
-      #
-      #   # bad
-      #   prepend M
-      #
-      #   class C
-      #   end
-      #
-      #   # good
-      #   class C
-      #     include M
-      #   end
-      #
-      #   # good
-      #   class C
-      #     extend M
-      #   end
-      #
-      #   # good
-      #   class C
-      #     prepend M
-      #   end
-      class MixinUsage < Cop
-        MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
-              'or `module`.'.freeze
-
-        def_node_matcher :include_statement, <<-PATTERN
-          (send nil? ${:include :extend :prepend}
-            const)
-        PATTERN
-
-        def on_send(node)
-          include_statement(node) do |statement|
-            return if node.argument? ||
-                      accepted_include?(node) ||
-                      belongs_to_class_or_module?(node)
-
-            add_offense(node, message: format(MSG, statement: statement))
-          end
-        end
-
-        private
-
-        def accepted_include?(node)
-          node.parent && node.macro?
-        end
-
-        def belongs_to_class_or_module?(node)
-          if !node.parent
-            false
-          else
-            return true if node.parent.class_type? || node.parent.module_type?
-
-            belongs_to_class_or_module?(node.parent)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/module_function.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for use of `extend self` or `module_function` in a
-      # module.
-      #
-      # Supported styles are: module_function, extend_self.
-      #
-      # @example EnforcedStyle: module_function (default)
-      #   # bad
-      #   module Test
-      #     extend self
-      #     # ...
-      #   end
-      #
-      #   # good
-      #   module Test
-      #     module_function
-      #     # ...
-      #   end
-      #
-      # In case there are private methods, the cop won't be activated.
-      # Otherwise, it forces to change the flow of the default code.
-      #
-      # @example EnforcedStyle: module_function (default)
-      #   # good
-      #   module Test
-      #     extend self
-      #     # ...
-      #     private
-      #     # ...
-      #   end
-      #
-      # @example EnforcedStyle: extend_self
-      #   # bad
-      #   module Test
-      #     module_function
-      #     # ...
-      #   end
-      #
-      #   # good
-      #   module Test
-      #     extend self
-      #     # ...
-      #   end
-      #
-      # These offenses are not safe to auto-correct since there are different
-      # implications to each approach.
-      class ModuleFunction < Cop
-        include ConfigurableEnforcedStyle
-
-        MODULE_FUNCTION_MSG =
-          'Use `module_function` instead of `extend self`.'.freeze
-        EXTEND_SELF_MSG =
-          'Use `extend self` instead of `module_function`.'.freeze
-
-        def_node_matcher :module_function_node?, '(send nil? :module_function)'
-        def_node_matcher :extend_self_node?, '(send nil? :extend self)'
-        def_node_matcher :private_directive?, '(send nil? :private ...)'
-
-        def on_module(node)
-          _name, body = *node
-          return unless body && body.begin_type?
-
-          each_wrong_style(body.children) do |child_node|
-            add_offense(child_node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            if extend_self_node?(node)
-              corrector.replace(node.source_range, 'module_function')
-            else
-              corrector.replace(node.source_range, 'extend self')
-            end
-          end
-        end
-
-        private
-
-        def each_wrong_style(nodes)
-          case style
-          when :module_function
-            private_directive = nodes.any? { |node| private_directive?(node) }
-
-            nodes.each do |node|
-              yield node if extend_self_node?(node) && !private_directive
-            end
-          when :extend_self
-            nodes.each do |node|
-              yield node if module_function_node?(node)
-            end
-          end
-        end
-
-        def message(_node)
-          style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/style/multiline_block_chain.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Style
-      # This cop checks for chaining of a block after another block that spans
-      # multiple lines.
-      #
-      # @example
-      #
-      #   Thread.list.find_all do |t|
-      #     t.alive?
-      #   end.map do |t|
-      #     t.object_id
-      #   end
-      class MultilineBlockChain < Cop
-        include RangeHelp
-
-        MSG = 'Avoid multi-line chains of blocks.'.freeze
-
-        def on_block(node)
-          node.send_node.each_node(:send) do |send_node|
-            receiver = send_node.receiver
-
-            next unless receiver && receiver.block_type? && receiver.multiline?
-
-            range = range_between(receiver.loc.end.begin_pos,
-                                  node.send_node.source_range.end_pos)
-
-            add_offense(nil, location: range)
-
-            # Done. If there are more blocks in the chain, they will be
-            # found by subsequent calls to on_block.
-            break
-          end
-        end
-      end
-    end
-  end
-end