cybrid_api_organization_ruby 0.0.35

data/vendor/bundle/ruby/3.1.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/class_structure.rb

@@ -0,0 +1,340 @@
+# 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:
+      #
+      # ```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.
+      #
+      # ```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://github.com/rubocop-hq/ruby-style-guide#consistent-classes
+      class ClassStructure < Cop
+        HUMANIZED_NODE_TYPE = {
+          casgn: :constants,
+          defs: :class_methods,
+          def: :public_methods,
+          sclass: :class_singleton
+        }.freeze
+
+        VISIBILITY_SCOPES = %i[private protected public].freeze
+        MSG = '`%<category>s` is supposed to appear before ' \
+              '`%<previous>s`.'.freeze
+
+        def_node_matcher :visibility_block?, <<-PATTERN
+          (send nil? { :private :protected :public })
+        PATTERN
+
+        # 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)
+            end
+            previous = index
+          end
+        end
+
+        # Autocorrect by swapping between two nodes autocorrecting them
+        def autocorrect(node)
+          node_classification = classify(node)
+          previous = left_siblings_of(node).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)
+
+          lambda do |corrector|
+            corrector.insert_before(previous_range, current_range.source)
+            corrector.remove(current_range)
+          end
+        end
+
+        private
+
+        # 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.children
+          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 node_visibility(node)
+          _, method_name, = *find_visibility_start(node)
+          method_name || :public
+        end
+
+        def find_visibility_start(node)
+          left_siblings_of(node)
+            .reverse
+            .find(&method(:visibility_block?))
+        end
+
+        # Navigate to find the last protected method
+        def find_visibility_end(node)
+          possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
+          right = right_siblings_of(node)
+          right.find do |child_node|
+            possible_visibilities.include?(node_visibility(child_node))
+          end || right.last
+        end
+
+        def siblings_of(node)
+          node.parent.children
+        end
+
+        def right_siblings_of(node)
+          siblings_of(node)[node.sibling_index..-1]
+        end
+
+        def left_siblings_of(node)
+          siblings_of(node)[0, node.sibling_index]
+        end
+
+        def humanize_node(node)
+          method_name, = *node
+          if node.def_type?
+            return :initializer if method_name == :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)
+          annotation_line = node.first_line - 1
+          first_comment = nil
+
+          processed_source.comments_before_line(annotation_line)
+                          .reverse_each do |comment|
+            if comment.location.line == annotation_line
+              first_comment = comment
+              annotation_line -= 1
+            end
+          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/3.1.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/closing_heredoc_indentation.rb

@@ -0,0 +1,126 @@
+# 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 < Cop
+        include Heredoc
+
+        SIMPLE_HEREDOC = '<<'.freeze
+        MSG = '`%<closing>s` is not aligned with `%<opening>s`.'.freeze
+        MSG_ARG = '`%<closing>s` is not aligned with `%<opening>s` or ' \
+                  'beginning of method definition.'.freeze
+
+        def on_heredoc(node)
+          return if heredoc_type(node) == SIMPLE_HEREDOC ||
+                    opening_indentation(node) == closing_indentation(node) ||
+                    argument_indentation_correct?(node)
+
+          add_offense(node, location: :heredoc_end)
+        end
+
+        def autocorrect(node)
+          lambda 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 && 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/3.1.0/gems/rubocop-0.66.0/lib/rubocop/cop/layout/closing_parenthesis_indentation.rb

@@ -0,0 +1,203 @@
+# 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)'
+                     .freeze
+        MSG_ALIGN = 'Align `)` with `(`.'.freeze
+
+        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 < 0 ? 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('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