plaid 14.11.0 → 14.11.1

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

@@ -0,0 +1,53 @@
+# 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 < Base
+        MSG =
+          'When using `method_missing`, define `respond_to_missing?`.'
+
+        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)
+          return false unless (grand_parent = node.parent.parent)
+
+          grand_parent.each_descendant(node.type) do |descendant|
+            return true if descendant.method?(:respond_to_missing?)
+
+            child = descendant.children.first
+            return true if child.respond_to?(:method?) && child.method?(:respond_to_missing?)
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# 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 < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MIXIN_METHODS = %i[extend include prepend].freeze
+        MSG = 'Put `%<mixin>s` mixins in %<suffix>s.'
+
+        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
+
+        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?
+          unless /\S/.match?(between.source)
+            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
+
+          message = format(MSG, mixin: send_node.method_name, suffix: 'a single statement')
+
+          add_offense(send_node, message: message) do |corrector|
+            range = send_node.loc.expression
+            mixins = sibling_mixins(send_node)
+            if send_node == mixins.first
+              correction = group_mixins(send_node, mixins)
+            else
+              range = range_to_remove_for_subsequent_mixin(mixins, send_node)
+              correction = ''
+            end
+
+            corrector.replace(range, correction)
+          end
+        end
+
+        def check_separated_style(send_node)
+          return if send_node.arguments.one?
+
+          message = format(MSG, mixin: send_node.method_name, suffix: 'separate statements')
+
+          add_offense(send_node, message: message) do |corrector|
+            range = send_node.loc.expression
+            correction = separate_mixins(send_node)
+
+            corrector.replace(range, correction)
+          end
+        end
+
+        def sibling_mixins(send_node)
+          siblings = send_node.parent.each_child_node(:send)
+                              .select(&:macro?)
+
+          siblings.select do |sibling_node|
+            sibling_node.method?(send_node.method_name)
+          end
+        end
+
+        def grouped_style?
+          style == :grouped
+        end
+
+        def separated_style?
+          style == :separated
+        end
+
+        def separate_mixins(node)
+          arguments = node.arguments.reverse
+          mixins = ["#{node.method_name} #{arguments.first.source}"]
+
+          arguments[1..-1].inject(mixins) do |replacement, arg|
+            replacement << "#{indent(node)}#{node.method_name} #{arg.source}"
+          end.join("\n")
+        end
+
+        def group_mixins(node, mixins)
+          mixin_names = mixins.reverse.flat_map do |mixin|
+            mixin.arguments.map(&:source)
+          end
+
+          "#{node.method_name} #{mixin_names.join(', ')}"
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# 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 < Base
+        MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
+              'or `module`.'
+        RESTRICT_ON_SEND = %i[include extend prepend].freeze
+
+        def_node_matcher :include_statement, <<~PATTERN
+          (send nil? ${:include :extend :prepend}
+            const)
+        PATTERN
+
+        def_node_matcher :wrapped_macro_scope?, <<~PATTERN
+          {({sclass class module block} ... ({begin if} ...))}
+        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? || ascend_macro_scope?(node.parent))
+        end
+
+        def ascend_macro_scope?(ancestor)
+          return true if wrapped_macro_scope?(ancestor)
+
+          ancestor.parent && ascend_macro_scope?(ancestor.parent)
+        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.91.1/lib/rubocop/cop/style/module_function.rb

@@ -0,0 +1,147 @@
+# 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, forbidden.
+      #
+      # @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
+      #
+      # The option `forbidden` prohibits the usage of both styles.
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   module Test
+      #     module_function
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #     private
+      #     # ...
+      #   end
+      #
+      # These offenses are not safe to auto-correct since there are different
+      # implications to each approach.
+      class ModuleFunction < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MODULE_FUNCTION_MSG =
+          'Use `module_function` instead of `extend self`.'
+        EXTEND_SELF_MSG =
+          'Use `extend self` instead of `module_function`.'
+        FORBIDDEN_MSG =
+          'Do not use `module_function` or `extend self`.'
+
+        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)
+          return unless node.body&.begin_type?
+
+          each_wrong_style(node.body.children) do |child_node|
+            add_offense(child_node) do |corrector|
+              next if style == :forbidden
+
+              if extend_self_node?(child_node)
+                corrector.replace(child_node, 'module_function')
+              else
+                corrector.replace(child_node, 'extend self')
+              end
+            end
+          end
+        end
+
+        private
+
+        def each_wrong_style(nodes, &block)
+          case style
+          when :module_function
+            check_module_function(nodes, &block)
+          when :extend_self
+            check_extend_self(nodes, &block)
+          when :forbidden
+            check_forbidden(nodes, &block)
+          end
+        end
+
+        def check_module_function(nodes)
+          private_directive = nodes.any? { |node| private_directive?(node) }
+
+          nodes.each do |node|
+            yield node if extend_self_node?(node) && !private_directive
+          end
+        end
+
+        def check_extend_self(nodes)
+          nodes.each do |node|
+            yield node if module_function_node?(node)
+          end
+        end
+
+        def check_forbidden(nodes)
+          nodes.each do |node|
+            yield node if extend_self_node?(node)
+            yield node if module_function_node?(node)
+          end
+        end
+
+        def message(_range)
+          return FORBIDDEN_MSG if style == :forbidden
+
+          style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# 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
+      #
+      #   # bad
+      #   Thread.list.select do |t|
+      #     t.alive?
+      #   end.map do |t|
+      #     t.object_id
+      #   end
+      #
+      #   # good
+      #   alive_threads = Thread.list.select do |t|
+      #     t.alive?
+      #   end
+      #   alive_threads.map do |t|
+      #     t.object_id
+      #   end
+      class MultilineBlockChain < Base
+        include RangeHelp
+
+        MSG = 'Avoid multi-line chains of blocks.'
+
+        def on_block(node)
+          node.send_node.each_node(:send) do |send_node|
+            receiver = send_node.receiver
+
+            next unless receiver&.block_type? && receiver&.multiline?
+
+            range = range_between(receiver.loc.end.begin_pos,
+                                  node.send_node.source_range.end_pos)
+
+            add_offense(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

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/multiline_if_modifier.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of if/unless modifiers with multiple-lines bodies.
+      #
+      # @example
+      #
+      #   # bad
+      #   {
+      #     result: 'this should not happen'
+      #   } unless cond
+      #
+      #   # good
+      #   { result: 'ok' } if cond
+      class MultilineIfModifier < Base
+        include StatementModifier
+        include Alignment
+        extend AutoCorrector
+
+        MSG = 'Favor a normal %<keyword>s-statement over a modifier' \
+              ' clause in a multiline statement.'
+
+        def on_if(node)
+          return unless node.modifier_form? && node.body.multiline?
+
+          add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
+            corrector.replace(node, to_normal_if(node))
+          end
+        end
+
+        private
+
+        def to_normal_if(node)
+          indented_body = indented_body(node.body, node)
+          condition = "#{node.keyword} #{node.condition.source}"
+          indented_end = "#{offset(node)}end"
+
+          [condition, indented_body, indented_end].join("\n")
+        end
+
+        def configured_indentation_width
+          super || 2
+        end
+
+        def indented_body(body, node)
+          body_source = "#{offset(node)}#{body.source}"
+          body_source.each_line.map do |line|
+            if line == "\n"
+              line
+            else
+              line.sub(/^\s{#{offset(node).length}}/, indentation(node))
+            end
+          end.join
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/multiline_if_then.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of the `then` keyword in multi-line if statements.
+      #
+      # @example
+      #   # bad
+      #   # This is considered bad practice.
+      #   if cond then
+      #   end
+      #
+      #   # good
+      #   # If statements can contain `then` on the same line.
+      #   if cond then a
+      #   elsif cond then b
+      #   end
+      class MultilineIfThen < Base
+        include OnNormalIfUnless
+        include RangeHelp
+        extend AutoCorrector
+
+        NON_MODIFIER_THEN = /then\s*(#.*)?$/.freeze
+
+        MSG = 'Do not use `then` for multi-line `%<keyword>s`.'
+
+        def on_normal_if_unless(node)
+          return unless non_modifier_then?(node)
+
+          add_offense(node.loc.begin, message: format(MSG, keyword: node.keyword)) do |corrector|
+            corrector.remove(range_with_surrounding_space(range: node.loc.begin, side: :left))
+          end
+        end
+
+        private
+
+        def non_modifier_then?(node)
+          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/style/multiline_memoization.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks expressions wrapping styles for multiline memoization.
+      #
+      # @example EnforcedStyle: keyword (default)
+      #   # bad
+      #   foo ||= (
+      #     bar
+      #     baz
+      #   )
+      #
+      #   # good
+      #   foo ||= begin
+      #     bar
+      #     baz
+      #   end
+      #
+      # @example EnforcedStyle: braces
+      #   # bad
+      #   foo ||= begin
+      #     bar
+      #     baz
+      #   end
+      #
+      #   # good
+      #   foo ||= (
+      #     bar
+      #     baz
+      #   )
+      class MultilineMemoization < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        KEYWORD_MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'
+        BRACES_MSG = 'Wrap multiline memoization blocks in `(` and `)`.'
+
+        def on_or_asgn(node)
+          _lhs, rhs = *node
+
+          return unless bad_rhs?(rhs)
+
+          add_offense(node.source_range) do |corrector|
+            if style == :keyword
+              keyword_autocorrect(rhs, corrector)
+            else
+              corrector.replace(rhs.loc.begin, '(')
+              corrector.replace(rhs.loc.end, ')')
+            end
+          end
+        end
+
+        def message(_node)
+          style == :braces ? BRACES_MSG : KEYWORD_MSG
+        end
+
+        private
+
+        def bad_rhs?(rhs)
+          return false unless rhs.multiline?
+
+          if style == :keyword
+            rhs.begin_type?
+          else
+            rhs.kwbegin_type?
+          end
+        end
+
+        def keyword_autocorrect(node, corrector)
+          node_buf = node.source_range.source_buffer
+          corrector.replace(node.loc.begin, keyword_begin_str(node, node_buf))
+          corrector.replace(node.loc.end, keyword_end_str(node, node_buf))
+        end
+
+        def keyword_begin_str(node, node_buf)
+          indent = config.for_cop('Layout/IndentationWidth')['Width'] || 2
+          if node_buf.source[node.loc.begin.end_pos] == "\n"
+            'begin'
+          else
+            "begin\n#{' ' * (node.loc.column + indent)}"
+          end
+        end
+
+        def keyword_end_str(node, node_buf)
+          if /[^\s)]/.match?(node_buf.source_line(node.loc.end.line))
+            "\n#{' ' * node.loc.column}end"
+          else
+            'end'
+          end
+        end
+      end
+    end
+  end
+end