primary_connect_proto 0.4.0 → 0.5.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/performance/fixed_size.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Do not compute the size of statically sized objects.
-      #
-      # @example
-      #   # String methods
-      #   # bad
-      #   'foo'.size
-      #   %q[bar].count
-      #   %(qux).length
-      #
-      #   # Symbol methods
-      #   # bad
-      #   :fred.size
-      #   :'baz'.length
-      #
-      #   # Array methods
-      #   # bad
-      #   [1, 2, thud].count
-      #   %W(1, 2, bar).size
-      #
-      #   # Hash methods
-      #   # bad
-      #   { a: corge, b: grault }.length
-      #
-      #   # good
-      #   foo.size
-      #   bar.count
-      #   qux.length
-      #
-      #   # good
-      #   :"#{fred}".size
-      #   CONST = :baz.length
-      #
-      #   # good
-      #   [1, 2, *thud].count
-      #   garply = [1, 2, 3]
-      #   garly.size
-      #
-      #   # good
-      #   { a: corge, **grault }.length
-      #   waldo = { a: corge, b: grault }
-      #   waldo.size
-      #
-      class FixedSize < Cop
-        MSG = 'Do not compute the size of statically sized objects.'.freeze
-
-        def_node_matcher :counter, <<-MATCHER
-          (send ${array hash str sym} {:count :length :size} $...)
-        MATCHER
-
-        def on_send(node)
-          return if allowed_parent?(node.parent)
-
-          counter(node) do |var, arg|
-            return if allowed_variable?(var) || allowed_argument?(arg)
-
-            add_offense(node)
-          end
-        end
-
-        private
-
-        def allowed_variable?(var)
-          contains_splat?(var) || contains_double_splat?(var)
-        end
-
-        def allowed_argument?(arg)
-          arg && non_string_argument?(arg.first)
-        end
-
-        def allowed_parent?(node)
-          node && (node.casgn_type? || node.block_type?)
-        end
-
-        def contains_splat?(node)
-          return unless node.array_type?
-
-          node.each_child_node(:splat).any?
-        end
-
-        def contains_double_splat?(node)
-          return unless node.hash_type?
-
-          node.each_child_node(:kwsplat).any?
-        end
-
-        def non_string_argument?(node)
-          node && !node.str_type?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/performance/flat_map.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop is used to identify usages of
-      #
-      # @example
-      #   # bad
-      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
-      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)
-      #
-      #   # good
-      #   [1, 2, 3, 4].flat_map { |e| [e, e] }
-      #   [1, 2, 3, 4].map { |e| [e, e] }.flatten
-      #   [1, 2, 3, 4].collect { |e| [e, e] }.flatten
-      class FlatMap < Cop
-        include RangeHelp
-
-        MSG = 'Use `flat_map` instead of `%<method>s...%<flatten>s`.'.freeze
-        FLATTEN_MULTIPLE_LEVELS = ' Beware, `flat_map` only flattens 1 level ' \
-                                  'and `flatten` can be used to flatten ' \
-                                  'multiple levels.'.freeze
-
-        def_node_matcher :flat_map_candidate?, <<-PATTERN
-          (send (block $(send _ ${:collect :map}) ...) ${:flatten :flatten!} $...)
-        PATTERN
-
-        def on_send(node)
-          flat_map_candidate?(node) do |map_node, first_method, flatten, params|
-            flatten_level, = *params.first
-            if cop_config['EnabledForFlattenWithoutParams'] && !flatten_level
-              offense_for_levels(node, map_node, first_method, flatten)
-            elsif flatten_level == 1
-              offense_for_method(node, map_node, first_method, flatten)
-            end
-          end
-        end
-
-        def autocorrect(node)
-          map_node, _first_method, _flatten, params = flat_map_candidate?(node)
-          flatten_level, = *params.first
-
-          return unless flatten_level
-
-          range = range_between(node.loc.dot.begin_pos,
-                                node.source_range.end_pos)
-
-          lambda do |corrector|
-            corrector.remove(range)
-            corrector.replace(map_node.loc.selector, 'flat_map')
-          end
-        end
-
-        private
-
-        def offense_for_levels(node, map_node, first_method, flatten)
-          message = MSG + FLATTEN_MULTIPLE_LEVELS
-          register_offense(node, map_node, first_method, flatten, message)
-        end
-
-        def offense_for_method(node, map_node, first_method, flatten)
-          register_offense(node, map_node, first_method, flatten, MSG)
-        end
-
-        def register_offense(node, map_node, first_method, flatten, message)
-          range = range_between(map_node.loc.selector.begin_pos,
-                                node.loc.expression.end_pos)
-
-          add_offense(node,
-                      location: range,
-                      message: format(message, method: first_method,
-                                               flatten: flatten))
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/performance/inefficient_hash_search.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop checks for inefficient searching of keys and values within
-      # hashes.
-      #
-      # `Hash#keys.include?` is less efficient than `Hash#key?` because
-      # the former allocates a new array and then performs an O(n) search
-      # through that array, while `Hash#key?` does not allocate any array and
-      # performs a faster O(1) search for the key.
-      #
-      # `Hash#values.include?` is less efficient than `Hash#value?`. While they
-      # both perform an O(n) search through all of the values, calling `values`
-      # allocates a new array while using `value?` does not.
-      #
-      # @example
-      #   # bad
-      #   { a: 1, b: 2 }.keys.include?(:a)
-      #   { a: 1, b: 2 }.keys.include?(:z)
-      #   h = { a: 1, b: 2 }; h.keys.include?(100)
-      #
-      #   # good
-      #   { a: 1, b: 2 }.key?(:a)
-      #   { a: 1, b: 2 }.has_key?(:z)
-      #   h = { a: 1, b: 2 }; h.key?(100)
-      #
-      #   # bad
-      #   { a: 1, b: 2 }.values.include?(2)
-      #   { a: 1, b: 2 }.values.include?('garbage')
-      #   h = { a: 1, b: 2 }; h.values.include?(nil)
-      #
-      #   # good
-      #   { a: 1, b: 2 }.value?(2)
-      #   { a: 1, b: 2 }.has_value?('garbage')
-      #   h = { a: 1, b: 2 }; h.value?(nil)
-      #
-      class InefficientHashSearch < Cop
-        def_node_matcher :inefficient_include?, <<-PATTERN
-          (send (send $_ {:keys :values}) :include? _)
-        PATTERN
-
-        def on_send(node)
-          inefficient_include?(node) do |receiver|
-            return if receiver.nil?
-
-            add_offense(node)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            # Replace `keys.include?` or `values.include?` with the appropriate
-            # `key?`/`value?` method.
-            corrector.replace(
-              node.loc.expression,
-              "#{autocorrect_hash_expression(node)}."\
-              "#{autocorrect_method(node)}(#{autocorrect_argument(node)})"
-            )
-          end
-        end
-
-        private
-
-        def message(node)
-          "Use `##{autocorrect_method(node)}` instead of "\
-            "`##{current_method(node)}.include?`."
-        end
-
-        def autocorrect_method(node)
-          case current_method(node)
-          when :keys then use_long_method ? 'has_key?' : 'key?'
-          when :values then use_long_method ? 'has_value?' : 'value?'
-          end
-        end
-
-        def current_method(node)
-          node.receiver.method_name
-        end
-
-        def use_long_method
-          preferred_config = config.for_all_cops['Style/PreferredHashMethods']
-          preferred_config &&
-            preferred_config['EnforcedStyle'] == 'long' &&
-            preferred_config['Enabled']
-        end
-
-        def autocorrect_argument(node)
-          node.arguments.first.source
-        end
-
-        def autocorrect_hash_expression(node)
-          node.receiver.receiver.source
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/performance/lstrip_rstrip.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where `lstrip.rstrip` can be replaced by
-      # `strip`.
-      #
-      # @example
-      #   # bad
-      #   'abc'.lstrip.rstrip
-      #   'abc'.rstrip.lstrip
-      #
-      #   # good
-      #   'abc'.strip
-      class LstripRstrip < Cop
-        include RangeHelp
-
-        MSG = 'Use `strip` instead of `%<methods>s`.'.freeze
-
-        def_node_matcher :lstrip_rstrip, <<-PATTERN
-          {(send $(send _ $:rstrip) $:lstrip)
-           (send $(send _ $:lstrip) $:rstrip)}
-        PATTERN
-
-        def on_send(node)
-          lstrip_rstrip(node) do |first_send, method_one, method_two|
-            range = range_between(first_send.loc.selector.begin_pos,
-                                  node.source_range.end_pos)
-            add_offense(node,
-                        location: range,
-                        message: format(MSG,
-                                        methods: "#{method_one}.#{method_two}"))
-          end
-        end
-
-        def autocorrect(node)
-          range = range_between(node.receiver.loc.selector.begin_pos,
-                                node.source_range.end_pos)
-
-          ->(corrector) { corrector.replace(range, 'strip') }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/performance/open_struct.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop checks for `OpenStruct.new` calls.
-      # Instantiation of an `OpenStruct` invalidates
-      # Ruby global method cache as it causes dynamic method
-      # definition during program runtime.
-      # This could have an effect on performance,
-      # especially in case of single-threaded
-      # applications with multiple `OpenStruct` instantiations.
-      #
-      # @example
-      #   # bad
-      #   class MyClass
-      #     def my_method
-      #       OpenStruct.new(my_key1: 'my_value1', my_key2: 'my_value2')
-      #     end
-      #   end
-      #
-      #   # good
-      #   class MyClass
-      #     MyStruct = Struct.new(:my_key1, :my_key2)
-      #     def my_method
-      #       MyStruct.new('my_value1', 'my_value2')
-      #     end
-      #   end
-      #
-      class OpenStruct < Cop
-        MSG = 'Consider using `Struct` over `OpenStruct` ' \
-              'to optimize the performance.'.freeze
-
-        def_node_matcher :open_struct, <<-PATTERN
-          (send (const {nil? cbase} :OpenStruct) :new ...)
-        PATTERN
-
-        def on_send(node)
-          open_struct(node) do |method|
-            add_offense(node, location: :selector, message: format(MSG, method))
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/performance/range_include.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies uses of `Range#include?`, which iterates over each
-      # item in a `Range` to see if a specified item is there. In contrast,
-      # `Range#cover?` simply compares the target item with the beginning and
-      # end points of the `Range`. In a great majority of cases, this is what
-      # is wanted.
-      #
-      # This cop is `Safe: false` by default because `Range#include?` and
-      # `Range#cover?` are not equivalent behaviour.
-      #
-      # @example
-      #   # bad
-      #   ('a'..'z').include?('b') # => true
-      #
-      #   # good
-      #   ('a'..'z').cover?('b') # => true
-      #
-      #   # Example of a case where `Range#cover?` may not provide
-      #   # the desired result:
-      #
-      #   ('a'..'z').cover?('yellow') # => true
-      class RangeInclude < Cop
-        MSG = 'Use `Range#cover?` instead of `Range#include?`.'.freeze
-
-        # TODO: If we traced out assignments of variables to their uses, we
-        # might pick up on a few more instances of this issue
-        # Right now, we only detect direct calls on a Range literal
-        # (We don't even catch it if the Range is in double parens)
-
-        def_node_matcher :range_include, <<-PATTERN
-          (send {irange erange (begin {irange erange})} :include? ...)
-        PATTERN
-
-        def on_send(node)
-          return unless range_include(node)
-
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'cover?') }
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/performance/redundant_block_call.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies the use of a `&block` parameter and `block.call`
-      # where `yield` would do just as well.
-      #
-      # @example
-      #   # bad
-      #   def method(&block)
-      #     block.call
-      #   end
-      #   def another(&func)
-      #     func.call 1, 2, 3
-      #   end
-      #
-      #   # good
-      #   def method
-      #     yield
-      #   end
-      #   def another
-      #     yield 1, 2, 3
-      #   end
-      class RedundantBlockCall < Cop
-        MSG = 'Use `yield` instead of `%<argname>s.call`.'.freeze
-        YIELD = 'yield'.freeze
-        OPEN_PAREN = '('.freeze
-        CLOSE_PAREN = ')'.freeze
-        SPACE = ' '.freeze
-
-        def_node_matcher :blockarg_def, <<-PATTERN
-          {(def  _   (args ... (blockarg $_)) $_)
-           (defs _ _ (args ... (blockarg $_)) $_)}
-        PATTERN
-
-        def_node_search :blockarg_calls, <<-PATTERN
-          (send (lvar %1) :call ...)
-        PATTERN
-
-        def_node_search :blockarg_assigned?, <<-PATTERN
-          (lvasgn %1 ...)
-        PATTERN
-
-        def on_def(node)
-          blockarg_def(node) do |argname, body|
-            next unless body
-
-            calls_to_report(argname, body).each do |blockcall|
-              add_offense(blockcall, message: format(MSG, argname: argname))
-            end
-          end
-        end
-
-        # offenses are registered on the `block.call` nodes
-        def autocorrect(node)
-          _receiver, _method, *args = *node
-          new_source = String.new(YIELD)
-          unless args.empty?
-            new_source += if parentheses?(node)
-                            OPEN_PAREN
-                          else
-                            SPACE
-                          end
-
-            new_source << args.map(&:source).join(', ')
-          end
-
-          new_source << CLOSE_PAREN if parentheses?(node) && !args.empty?
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
-        end
-
-        private
-
-        def calls_to_report(argname, body)
-          return [] if blockarg_assigned?(body, argname)
-
-          calls = to_enum(:blockarg_calls, body, argname)
-
-          return [] if calls.any? { |call| args_include_block_pass?(call) }
-
-          calls
-        end
-
-        def args_include_block_pass?(blockcall)
-          _receiver, _call, *args = *blockcall
-
-          args.any?(&:block_pass_type?)
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.66.0/lib/rubocop/cop/performance/redundant_match.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies the use of `Regexp#match` or `String#match`, which
-      # returns `#<MatchData>`/`nil`. The return value of `=~` is an integral
-      # index/`nil` and is more performant.
-      #
-      # @example
-      #   # bad
-      #   do_something if str.match(/regex/)
-      #   while regex.match('str')
-      #     do_something
-      #   end
-      #
-      #   # good
-      #   method(str =~ /regex/)
-      #   return value unless regex =~ 'str'
-      class RedundantMatch < Cop
-        MSG = 'Use `=~` in places where the `MatchData` returned by ' \
-              '`#match` will not be used.'.freeze
-
-        # 'match' is a fairly generic name, so we don't flag it unless we see
-        # a string or regexp literal on one side or the other
-        def_node_matcher :match_call?, <<-PATTERN
-          {(send {str regexp} :match _)
-           (send !nil? :match {str regexp})}
-        PATTERN
-
-        def_node_matcher :only_truthiness_matters?, <<-PATTERN
-          ^({if while until case while_post until_post} equal?(%0) ...)
-        PATTERN
-
-        def on_send(node)
-          return unless match_call?(node) &&
-                        (!node.value_used? || only_truthiness_matters?(node)) &&
-                        !(node.parent && node.parent.block_type?)
-
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          # Regexp#match can take a second argument, but this cop doesn't
-          # register an offense in that case
-          return unless node.first_argument.regexp_type?
-
-          new_source =
-            node.receiver.source + ' =~ ' + node.first_argument.source
-
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
-        end
-      end
-    end
-  end
-end