plaid 14.7.0 → 14.8.0

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/layout/class_structure.rb

@@ -1,305 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks if the code style follows the ExpectedOrder configuration:
-      #
-      # `Categories` allows us to map macro names into a category.
-      #
-      # Consider an example of code style that covers the following order:
-      #
-      # * Module inclusion (include, prepend, extend)
-      # * Constants
-      # * Associations (has_one, has_many)
-      # * Public attribute macros (attr_accessor, attr_writer, attr_reader)
-      # * Other macros (validates, validate)
-      # * Public class methods
-      # * Initializer
-      # * Public instance methods
-      # * Protected attribute macros (attr_accessor, attr_writer, attr_reader)
-      # * Protected instance methods
-      # * Private attribute macros (attr_accessor, attr_writer, attr_reader)
-      # * Private instance methods
-      #
-      # You can configure the following order:
-      #
-      # [source,yaml]
-      # ----
-      #  Layout/ClassStructure:
-      #    ExpectedOrder:
-      #      - module_inclusion
-      #      - constants
-      #      - association
-      #      - public_attribute_macros
-      #      - public_delegate
-      #      - macros
-      #      - public_class_methods
-      #      - initializer
-      #      - public_methods
-      #      - protected_attribute_macros
-      #      - protected_methods
-      #      - private_attribute_macros
-      #      - private_delegate
-      #      - private_methods
-      # ----
-      #
-      # Instead of putting all literals in the expected order, is also
-      # possible to group categories of macros. Visibility levels are handled
-      # automatically.
-      #
-      # [source,yaml]
-      # ----
-      #  Layout/ClassStructure:
-      #    Categories:
-      #      association:
-      #        - has_many
-      #        - has_one
-      #      attribute_macros:
-      #        - attr_accessor
-      #        - attr_reader
-      #        - attr_writer
-      #      macros:
-      #        - validates
-      #        - validate
-      #      module_inclusion:
-      #        - include
-      #        - prepend
-      #        - extend
-      # ----
-      #
-      # @example
-      #   # bad
-      #   # Expect extend be before constant
-      #   class Person < ApplicationRecord
-      #     has_many :orders
-      #     ANSWER = 42
-      #
-      #     extend SomeModule
-      #     include AnotherModule
-      #   end
-      #
-      #   # good
-      #   class Person
-      #     # extend and include go first
-      #     extend SomeModule
-      #     include AnotherModule
-      #
-      #     # inner classes
-      #     CustomError = Class.new(StandardError)
-      #
-      #     # constants are next
-      #     SOME_CONSTANT = 20
-      #
-      #     # afterwards we have public attribute macros
-      #     attr_reader :name
-      #
-      #     # followed by other macros (if any)
-      #     validates :name
-      #
-      #     # then we have public delegate macros
-      #     delegate :to_s, to: :name
-      #
-      #     # public class methods are next in line
-      #     def self.some_method
-      #     end
-      #
-      #     # initialization goes between class methods and instance methods
-      #     def initialize
-      #     end
-      #
-      #     # followed by other public instance methods
-      #     def some_method
-      #     end
-      #
-      #     # protected attribute macros and methods go next
-      #     protected
-      #
-      #     attr_reader :protected_name
-      #
-      #     def some_protected_method
-      #     end
-      #
-      #     # private attribute macros, delegate macros and methods
-      #     # are grouped near the end
-      #     private
-      #
-      #     attr_reader :private_name
-      #
-      #     delegate :some_private_delegate, to: :name
-      #
-      #     def some_private_method
-      #     end
-      #   end
-      #
-      # @see https://rubystyle.guide#consistent-classes
-      class ClassStructure < Base
-        include VisibilityHelp
-        extend AutoCorrector
-
-        HUMANIZED_NODE_TYPE = {
-          casgn: :constants,
-          defs: :class_methods,
-          def: :public_methods,
-          sclass: :class_singleton
-        }.freeze
-
-        MSG = '`%<category>s` is supposed to appear before ' \
-              '`%<previous>s`.'
-
-        # Validates code style on class declaration.
-        # Add offense when find a node out of expected order.
-        def on_class(class_node)
-          previous = -1
-          walk_over_nested_class_definition(class_node) do |node, category|
-            index = expected_order.index(category)
-            if index < previous
-              message = format(MSG, category: category,
-                                    previous: expected_order[previous])
-              add_offense(node, message: message) do |corrector|
-                autocorrect(corrector, node)
-              end
-            end
-            previous = index
-          end
-        end
-
-        private
-
-        # Autocorrect by swapping between two nodes autocorrecting them
-        def autocorrect(corrector, node)
-          node_classification = classify(node)
-          previous = node.left_siblings.find do |sibling|
-            classification = classify(sibling)
-            !ignore?(classification) && node_classification != classification
-          end
-
-          current_range = source_range_with_comment(node)
-          previous_range = source_range_with_comment(previous)
-
-          corrector.insert_before(previous_range, current_range.source)
-          corrector.remove(current_range)
-        end
-
-        # Classifies a node to match with something in the {expected_order}
-        # @param node to be analysed
-        # @return String when the node type is a `:block` then
-        #   {classify} recursively with the first children
-        # @return String when the node type is a `:send` then {find_category}
-        #   by method name
-        # @return String otherwise trying to {humanize_node} of the current node
-        def classify(node)
-          return node.to_s unless node.respond_to?(:type)
-
-          case node.type
-          when :block
-            classify(node.send_node)
-          when :send
-            find_category(node)
-          else
-            humanize_node(node)
-          end.to_s
-        end
-
-        # Categorize a node according to the {expected_order}
-        # Try to match {categories} values against the node's method_name given
-        # also its visibility.
-        # @param node to be analysed.
-        # @return [String] with the key category or the `method_name` as string
-        def find_category(node)
-          name = node.method_name.to_s
-          category, = categories.find { |_, names| names.include?(name) }
-          key = category || name
-          visibility_key = "#{node_visibility(node)}_#{key}"
-          expected_order.include?(visibility_key) ? visibility_key : key
-        end
-
-        def walk_over_nested_class_definition(class_node)
-          class_elements(class_node).each do |node|
-            classification = classify(node)
-            next if ignore?(classification)
-
-            yield node, classification
-          end
-        end
-
-        def class_elements(class_node)
-          class_def = class_node.body
-
-          return [] unless class_def
-
-          if class_def.def_type? || class_def.send_type?
-            [class_def]
-          else
-            class_def.children.compact
-          end
-        end
-
-        def ignore?(classification)
-          classification.nil? ||
-            classification.to_s.end_with?('=') ||
-            expected_order.index(classification).nil?
-        end
-
-        def humanize_node(node)
-          if node.def_type?
-            return :initializer if node.method?(:initialize)
-
-            return "#{node_visibility(node)}_methods"
-          end
-          HUMANIZED_NODE_TYPE[node.type] || node.type
-        end
-
-        def source_range_with_comment(node)
-          begin_pos, end_pos =
-            if node.def_type?
-              start_node = find_visibility_start(node) || node
-              end_node = find_visibility_end(node) || node
-              [begin_pos_with_comment(start_node),
-               end_position_for(end_node) + 1]
-            else
-              [begin_pos_with_comment(node), end_position_for(node)]
-            end
-
-          Parser::Source::Range.new(buffer, begin_pos, end_pos)
-        end
-
-        def end_position_for(node)
-          end_line = buffer.line_for_position(node.loc.expression.end_pos)
-          buffer.line_range(end_line).end_pos
-        end
-
-        def begin_pos_with_comment(node)
-          first_comment = nil
-          (node.first_line - 1).downto(1) do |annotation_line|
-            break unless (comment = processed_source.comment_at_line(annotation_line))
-
-            first_comment = comment
-          end
-
-          start_line_position(first_comment || node)
-        end
-
-        def start_line_position(node)
-          buffer.line_range(node.loc.line).begin_pos - 1
-        end
-
-        def buffer
-          processed_source.buffer
-        end
-
-        # Load expected order from `ExpectedOrder` config.
-        # Define new terms in the expected order by adding new {categories}.
-        def expected_order
-          cop_config['ExpectedOrder']
-        end
-
-        # Setting categories hash allow you to group methods in group to match
-        # in the {expected_order}.
-        def categories
-          cop_config['Categories']
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/layout/closing_heredoc_indentation.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      #
-      # Checks the indentation of here document closings.
-      #
-      # @example
-      #
-      #   # bad
-      #   class Foo
-      #     def bar
-      #       <<~SQL
-      #         'Hi'
-      #     SQL
-      #     end
-      #   end
-      #
-      #   # good
-      #   class Foo
-      #     def bar
-      #       <<~SQL
-      #         'Hi'
-      #       SQL
-      #     end
-      #   end
-      #
-      #   # bad
-      #
-      #   # heredoc contents is before closing heredoc.
-      #   foo arg,
-      #       <<~EOS
-      #     Hi
-      #       EOS
-      #
-      #   # good
-      #   foo arg,
-      #       <<~EOS
-      #     Hi
-      #   EOS
-      #
-      #   # good
-      #   foo arg,
-      #       <<~EOS
-      #         Hi
-      #       EOS
-      #
-      class ClosingHeredocIndentation < Base
-        include Heredoc
-        extend AutoCorrector
-
-        SIMPLE_HEREDOC = '<<'
-        MSG = '`%<closing>s` is not aligned with `%<opening>s`.'
-        MSG_ARG = '`%<closing>s` is not aligned with `%<opening>s` or ' \
-                  'beginning of method definition.'
-
-        def on_heredoc(node)
-          return if heredoc_type(node) == SIMPLE_HEREDOC ||
-                    opening_indentation(node) == closing_indentation(node) ||
-                    argument_indentation_correct?(node)
-
-          message = message(node)
-          add_offense(node.loc.heredoc_end, message: message) do |corrector|
-            corrector.replace(node.loc.heredoc_end, indented_end(node))
-          end
-        end
-
-        private
-
-        def opening_indentation(node)
-          indent_level(heredoc_opening(node))
-        end
-
-        def argument_indentation_correct?(node)
-          return unless node.argument? || node.chained?
-
-          opening_indentation(
-            find_node_used_heredoc_argument(node.parent)
-          ) == closing_indentation(node)
-        end
-
-        def closing_indentation(node)
-          indent_level(heredoc_closing(node))
-        end
-
-        def heredoc_opening(node)
-          node.loc.expression.source_line
-        end
-
-        def heredoc_closing(node)
-          node.loc.heredoc_end.source_line
-        end
-
-        def indented_end(node)
-          closing_indent = closing_indentation(node)
-          opening_indent = opening_indentation(node)
-          closing_text = heredoc_closing(node)
-          closing_text.gsub(/^\s{#{closing_indent}}/, ' ' * opening_indent)
-        end
-
-        def find_node_used_heredoc_argument(node)
-          if node.parent&.send_type?
-            find_node_used_heredoc_argument(node.parent)
-          else
-            node
-          end
-        end
-
-        def message(node)
-          format(
-            node.argument? ? MSG_ARG : MSG,
-            closing: heredoc_closing(node).strip,
-            opening: heredoc_opening(node).strip
-          )
-        end
-
-        def indent_level(source_line)
-          source_line[/\A */].length
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/rubocop-0.91.1/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # This cop checks the indentation of hanging closing parentheses in
-      # method calls, method definitions, and grouped expressions. A hanging
-      # closing parenthesis means `)` preceded by a line break.
-      #
-      # @example
-      #
-      #   # bad
-      #   some_method(
-      #     a,
-      #     b
-      #     )
-      #
-      #   some_method(
-      #     a, b
-      #     )
-      #
-      #   some_method(a, b, c
-      #     )
-      #
-      #   some_method(a,
-      #               b,
-      #               c
-      #     )
-      #
-      #   some_method(a,
-      #     x: 1,
-      #     y: 2
-      #     )
-      #
-      #   # Scenario 1: When First Parameter Is On Its Own Line
-      #
-      #   # good: when first param is on a new line, right paren is *always*
-      #   #       outdented by IndentationWidth
-      #   some_method(
-      #     a,
-      #     b
-      #   )
-      #
-      #   # good
-      #   some_method(
-      #     a, b
-      #   )
-      #
-      #   # Scenario 2: When First Parameter Is On The Same Line
-      #
-      #   # good: when all other params are also on the same line, outdent
-      #   #       right paren by IndentationWidth
-      #   some_method(a, b, c
-      #              )
-      #
-      #   # good: when all other params are on multiple lines, but are lined
-      #   #       up, align right paren with left paren
-      #   some_method(a,
-      #               b,
-      #               c
-      #              )
-      #
-      #   # good: when other params are not lined up on multiple lines, outdent
-      #   #       right paren by IndentationWidth
-      #   some_method(a,
-      #     x: 1,
-      #     y: 2
-      #   )
-      #
-      #
-      class ClosingParenthesisIndentation < Cop
-        include Alignment
-
-        MSG_INDENT = 'Indent `)` to column %<expected>d (not %<actual>d)'
-
-        MSG_ALIGN = 'Align `)` with `(`.'
-
-        def on_send(node)
-          check(node, node.arguments)
-        end
-        alias on_csend on_send
-
-        def on_begin(node)
-          check(node, node.children)
-        end
-
-        def on_def(node)
-          check(node.arguments, node.arguments)
-        end
-        alias on_defs on_def
-
-        def autocorrect(node)
-          AlignmentCorrector.correct(processed_source, node, @column_delta)
-        end
-
-        private
-
-        def check(node, elements)
-          if elements.empty?
-            check_for_no_elements(node)
-          else
-            check_for_elements(node, elements)
-          end
-        end
-
-        def check_for_elements(node, elements)
-          left_paren  = node.loc.begin
-          right_paren = node.loc.end
-
-          return unless right_paren && begins_its_line?(right_paren)
-
-          correct_column = expected_column(left_paren, elements)
-
-          @column_delta = correct_column - right_paren.column
-
-          return if @column_delta.zero?
-
-          add_offense(right_paren,
-                      location: right_paren,
-                      message:  message(correct_column,
-                                        left_paren,
-                                        right_paren))
-        end
-
-        def check_for_no_elements(node)
-          left_paren = node.loc.begin
-          right_paren = node.loc.end
-          return unless right_paren && begins_its_line?(right_paren)
-
-          candidates = correct_column_candidates(node, left_paren)
-
-          return if candidates.include?(right_paren.column)
-
-          # Although there are multiple choices for a correct column,
-          # select the first one of candidates to determine a specification.
-          correct_column = candidates.first
-          @column_delta = correct_column - right_paren.column
-          add_offense(right_paren,
-                      location: right_paren,
-                      message:  message(correct_column,
-                                        left_paren,
-                                        right_paren))
-        end
-
-        def expected_column(left_paren, elements)
-          if line_break_after_left_paren?(left_paren, elements)
-            source_indent = processed_source
-                            .line_indentation(first_argument_line(elements))
-            new_indent    = source_indent - indentation_width
-
-            new_indent.negative? ? 0 : new_indent
-          elsif all_elements_aligned?(elements)
-            left_paren.column
-          else
-            processed_source.line_indentation(first_argument_line(elements))
-          end
-        end
-
-        def all_elements_aligned?(elements)
-          elements
-            .map { |e| e.loc.column }
-            .uniq
-            .count == 1
-        end
-
-        def first_argument_line(elements)
-          elements
-            .first
-            .loc
-            .first_line
-        end
-
-        def correct_column_candidates(node, left_paren)
-          [
-            processed_source.line_indentation(left_paren.line),
-            left_paren.column,
-            node.loc.column
-          ]
-        end
-
-        def message(correct_column, left_paren, right_paren)
-          if correct_column == left_paren.column
-            MSG_ALIGN
-          else
-            format(
-              MSG_INDENT,
-              expected: correct_column,
-              actual: right_paren.column
-            )
-          end
-        end
-
-        def indentation_width
-          @config.for_cop('Layout/IndentationWidth')['Width'] || 2
-        end
-
-        def line_break_after_left_paren?(left_paren, elements)
-          elements.first && elements.first.loc.line > left_paren.line
-        end
-      end
-    end
-  end
-end