study_line 0.1.6 → 0.2.1

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # This mixin detects collections that are safe to "break"
-    # by inserting new lines. This is useful for breaking
-    # up long lines.
-    #
-    # Let's look at hashes as an example:
-    #
-    # We know hash keys are safe to break across lines. We can add
-    # linebreaks into hashes on lines longer than the specified maximum.
-    # Then in further passes cops can clean up the multi-line hash.
-    # For example, say the maximum line length is as indicated below:
-    #
-    #                                         |
-    #                                         v
-    # {foo: "0000000000", bar: "0000000000", baz: "0000000000"}
-    #
-    # In a LineLength autocorrection pass, a line is added before
-    # the first key that exceeds the column limit:
-    #
-    # {foo: "0000000000", bar: "0000000000",
-    # baz: "0000000000"}
-    #
-    # In a MultilineHashKeyLineBreaks pass, lines are inserted
-    # before all keys:
-    #
-    # {foo: "0000000000",
-    # bar: "0000000000",
-    # baz: "0000000000"}
-    #
-    # Then in future passes FirstHashElementLineBreak,
-    # MultilineHashBraceLayout, and TrailingCommaInHashLiteral will
-    # manipulate as well until we get:
-    #
-    # {
-    #   foo: "0000000000",
-    #   bar: "0000000000",
-    #   baz: "0000000000",
-    # }
-    #
-    # (Note: Passes may not happen exactly in this sequence.)
-    module CheckLineBreakable
-      def extract_breakable_node(node, max)
-        if node.send_type?
-          args = process_args(node.arguments)
-          return extract_breakable_node_from_elements(node, args, max)
-        elsif node.def_type?
-          return extract_breakable_node_from_elements(node, node.arguments, max)
-        elsif node.array_type? || node.hash_type?
-          return extract_breakable_node_from_elements(node, node.children, max)
-        end
-        nil
-      end
-
-      private
-
-      # @api private
-      def extract_breakable_node_from_elements(node, elements, max)
-        return unless breakable_collection?(node, elements)
-        return if safe_to_ignore?(node)
-
-        line = processed_source.lines[node.first_line - 1]
-        return if processed_source.line_with_comment?(node.loc.line)
-        return if line.length <= max
-
-        extract_first_element_over_column_limit(node, elements, max)
-      end
-
-      # @api private
-      def extract_first_element_over_column_limit(node, elements, max)
-        line = node.first_line
-
-        # If a `send` node is not parenthesized, don't move the first element, because it
-        # can result in changed behavior or a syntax error.
-        if node.send_type? && !node.parenthesized? && !first_argument_is_heredoc?(node)
-          elements = elements.drop(1)
-        end
-
-        i = 0
-        i += 1 while within_column_limit?(elements[i], max, line)
-        i = shift_elements_for_heredoc_arg(node, elements, i)
-
-        return if i.nil?
-        return elements.first if i.zero?
-
-        elements[i - 1]
-      end
-
-      # @api private
-      def first_argument_is_heredoc?(node)
-        first_argument = node.first_argument
-
-        first_argument.respond_to?(:heredoc?) && first_argument.heredoc?
-      end
-
-      # @api private
-      # If a send node contains a heredoc argument, splitting cannot happen
-      # after the heredoc or else it will cause a syntax error.
-      def shift_elements_for_heredoc_arg(node, elements, index)
-        return index unless node.send_type? || node.array_type?
-
-        heredoc_index = elements.index { |arg| arg.respond_to?(:heredoc?) && arg.heredoc? }
-        return index unless heredoc_index
-        return nil if heredoc_index.zero?
-
-        heredoc_index >= index ? index : heredoc_index + 1
-      end
-
-      # @api private
-      def within_column_limit?(element, max, line)
-        element && element.loc.column <= max && element.loc.line == line
-      end
-
-      # @api private
-      def safe_to_ignore?(node)
-        return true unless max
-        return true if already_on_multiple_lines?(node)
-
-        # If there's a containing breakable collection on the same
-        # line, we let that one get broken first. In a separate pass,
-        # this one might get broken as well, but to avoid conflicting
-        # or redundant edits, we only mark one offense at a time.
-        return true if contained_by_breakable_collection_on_same_line?(node)
-
-        return true if contained_by_multiline_collection_that_could_be_broken_up?(node)
-
-        false
-      end
-
-      # @api private
-      def breakable_collection?(node, elements)
-        # For simplicity we only want to insert breaks in normal
-        # hashes wrapped in a set of curly braces like {foo: 1}.
-        # That is, not a kwargs hash. For method calls, this ensures
-        # the method call is made with parens.
-        starts_with_bracket = !node.hash_type? || node.loc.begin
-
-        # If the call has a second argument, we can insert a line
-        # break before the second argument and the rest of the
-        # argument will get auto-formatted onto separate lines
-        # by other cops.
-        has_second_element = elements.length >= 2
-
-        starts_with_bracket && has_second_element
-      end
-
-      # @api private
-      def contained_by_breakable_collection_on_same_line?(node)
-        node.each_ancestor.find do |ancestor|
-          # Ignore ancestors on different lines.
-          break if ancestor.first_line != node.first_line
-
-          if ancestor.hash_type? || ancestor.array_type?
-            elements = ancestor.children
-          elsif ancestor.send_type?
-            elements = process_args(ancestor.arguments)
-          else
-            next
-          end
-
-          return true if breakable_collection?(ancestor, elements)
-        end
-
-        false
-      end
-
-      # @api private
-      def contained_by_multiline_collection_that_could_be_broken_up?(node)
-        node.each_ancestor.find do |ancestor|
-          if (ancestor.hash_type? || ancestor.array_type?) &&
-             breakable_collection?(ancestor, ancestor.children)
-            return children_could_be_broken_up?(ancestor.children)
-          end
-
-          next unless ancestor.send_type?
-
-          args = process_args(ancestor.arguments)
-          return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
-        end
-
-        false
-      end
-
-      # @api private
-      def children_could_be_broken_up?(children)
-        return false if all_on_same_line?(children)
-
-        last_seen_line = -1
-        children.each do |child|
-          return true if last_seen_line >= child.first_line
-
-          last_seen_line = child.last_line
-        end
-        false
-      end
-
-      # @api private
-      def all_on_same_line?(nodes)
-        return true if nodes.empty?
-
-        nodes.first.first_line == nodes.last.last_line
-      end
-
-      # @api private
-      def process_args(args)
-        # If there is a trailing hash arg without explicit braces, like this:
-        #
-        #    method(1, 'key1' => value1, 'key2' => value2)
-        #
-        # ...then each key/value pair is treated as a method 'argument'
-        # when determining where line breaks should appear.
-        last_arg = args.last
-        args = args[0...-1] + last_arg.children if last_arg&.hash_type? && !last_arg&.braces?
-        args
-      end
-
-      # @api private
-      def already_on_multiple_lines?(node)
-        return node.first_line != node.arguments.last.last_line if node.def_type?
-
-        !node.single_line?
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/mixin/configurable_formatting.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Shared functionality between mixins that enforce naming conventions
-    module ConfigurableFormatting
-      include ConfigurableEnforcedStyle
-
-      def check_name(node, name, name_range)
-        if valid_name?(node, name)
-          correct_style_detected
-        else
-          add_offense(name_range, message: message(style)) { report_opposing_styles(node, name) }
-        end
-      end
-
-      def report_opposing_styles(node, name)
-        alternative_styles.each do |alternative|
-          return unexpected_style_detected(alternative) if valid_name?(node, name, alternative)
-        end
-      end
-
-      def valid_name?(node, name, given_style = style)
-        name.match?(self.class::FORMATS.fetch(given_style)) || class_emitter_method?(node, name)
-      end
-
-      # A class emitter method is a singleton method in a class/module, where
-      # the method has the same name as a class defined in the class/module.
-      def class_emitter_method?(node, name)
-        return false unless node.parent && node.defs_type?
-
-        # a class emitter method may be defined inside `def self.included`,
-        # `def self.extended`, etc.
-        node = node.parent while node.parent.defs_type?
-
-        node.parent.each_child_node(:class).any? { |c| c.loc.name.is?(name.to_s) }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/mixin/preceding_following_alignment.rb

@@ -1,181 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking whether an AST node/token is aligned
-    # with something on a preceding or following line
-    module PrecedingFollowingAlignment
-      private
-
-      def allow_for_alignment?
-        cop_config['AllowForAlignment']
-      end
-
-      def aligned_with_something?(range)
-        aligned_with_adjacent_line?(range, method(:aligned_token?))
-      end
-
-      def aligned_with_operator?(range)
-        aligned_with_adjacent_line?(range, method(:aligned_operator?))
-      end
-
-      def aligned_with_preceding_assignment(token)
-        preceding_line_range = token.line.downto(1)
-
-        aligned_with_assignment(token, preceding_line_range)
-      end
-
-      def aligned_with_subsequent_assignment(token)
-        subsequent_line_range = token.line.upto(processed_source.lines.length)
-
-        aligned_with_assignment(token, subsequent_line_range)
-      end
-
-      def aligned_with_adjacent_line?(range, predicate)
-        # minus 2 because node.loc.line is zero-based
-        pre  = (range.line - 2).downto(0)
-        post = range.line.upto(processed_source.lines.size - 1)
-
-        aligned_with_any_line_range?([pre, post], range, &predicate)
-      end
-
-      def aligned_with_any_line_range?(line_ranges, range, &predicate)
-        return true if aligned_with_any_line?(line_ranges, range, &predicate)
-
-        # If no aligned token was found, search for an aligned token on the
-        # nearest line with the same indentation as the checked line.
-        base_indentation = processed_source.lines[range.line - 1] =~ /\S/
-
-        aligned_with_any_line?(line_ranges, range, base_indentation, &predicate)
-      end
-
-      def aligned_with_any_line?(line_ranges, range, indent = nil, &predicate)
-        line_ranges.any? { |line_nos| aligned_with_line?(line_nos, range, indent, &predicate) }
-      end
-
-      def aligned_with_line?(line_nos, range, indent = nil)
-        line_nos.each do |lineno|
-          next if aligned_comment_lines.include?(lineno + 1)
-
-          line = processed_source.lines[lineno]
-          index = line =~ /\S/
-          next unless index
-          next if indent && indent != index
-
-          return yield(range, line)
-        end
-        false
-      end
-
-      def aligned_comment_lines
-        @aligned_comment_lines ||=
-          processed_source.comments.map(&:loc).select do |r|
-            begins_its_line?(r.expression)
-          end.map(&:line)
-      end
-
-      def aligned_token?(range, line)
-        aligned_words?(range, line) || aligned_assignment?(range, line)
-      end
-
-      def aligned_operator?(range, line)
-        (aligned_identical?(range, line) || aligned_assignment?(range, line))
-      end
-
-      def aligned_words?(range, line)
-        left_edge = range.column
-        return true if /\s\S/.match?(line[left_edge - 1, 2])
-
-        token = range.source
-        token == line[left_edge, token.length]
-      end
-
-      def aligned_assignment?(range, line)
-        (range.source[-1] == '=' && line[range.last_column - 1] == '=') ||
-          aligned_with_append_operator?(range, line)
-      end
-
-      def aligned_with_append_operator?(range, line)
-        last_column = range.last_column
-
-        (range.source == '<<' && line[last_column - 1] == '=') ||
-          (range.source[-1] == '=' && line[(last_column - 2)..(last_column - 1)] == '<<')
-      end
-
-      def aligned_identical?(range, line)
-        range.source == line[range.column, range.size]
-      end
-
-      def aligned_with_assignment(token, line_range)
-        token_line_indent    = processed_source.line_indentation(token.line)
-        assignment_lines     = relevant_assignment_lines(line_range)
-        relevant_line_number = assignment_lines[1]
-
-        return :none unless relevant_line_number
-
-        relevant_indent = processed_source.line_indentation(relevant_line_number)
-
-        return :none if relevant_indent < token_line_indent
-
-        assignment_line = processed_source.lines[relevant_line_number - 1]
-
-        return :none unless assignment_line
-
-        aligned_assignment?(token.pos, assignment_line) ? :yes : :no
-      end
-
-      def assignment_lines
-        @assignment_lines ||= assignment_tokens.map(&:line)
-      end
-
-      def assignment_tokens
-        @assignment_tokens ||= begin
-          tokens = processed_source.tokens.select(&:equal_sign?)
-
-          # we don't want to operate on equals signs which are part of an
-          #   optarg in a method definition
-          # e.g.: def method(optarg = default_val); end
-          tokens = remove_optarg_equals(tokens, processed_source)
-
-          # Only attempt to align the first = on each line
-          Set.new(tokens.uniq(&:line))
-        end
-      end
-
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
-      def relevant_assignment_lines(line_range)
-        result                        = []
-        original_line_indent          = processed_source.line_indentation(line_range.first)
-        relevant_line_indent_at_level = true
-
-        line_range.each do |line_number|
-          current_line_indent = processed_source.line_indentation(line_number)
-          blank_line          = processed_source.lines[line_number - 1].blank?
-
-          if (current_line_indent < original_line_indent && !blank_line) ||
-             (relevant_line_indent_at_level && blank_line)
-            break
-          end
-
-          result << line_number if assignment_lines.include?(line_number) &&
-                                   current_line_indent == original_line_indent
-
-          unless blank_line
-            relevant_line_indent_at_level = current_line_indent == original_line_indent
-          end
-        end
-
-        result
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity, Metrics/MethodLength
-
-      def remove_optarg_equals(asgn_tokens, processed_source)
-        optargs    = processed_source.ast.each_node(:optarg)
-        optarg_eql = optargs.to_set { |o| o.loc.operator.begin_pos }
-        asgn_tokens.reject { |t| optarg_eql.include?(t.begin_pos) }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/mixin/space_before_punctuation.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for cops checking for space before
-    # punctuation.
-    module SpaceBeforePunctuation
-      include RangeHelp
-
-      MSG = 'Space found before %<token>s.'
-
-      def on_new_investigation
-        each_missing_space(processed_source.sorted_tokens) do |token, pos_before|
-          add_offense(pos_before, message: format(MSG, token: kind(token))) do |corrector|
-            PunctuationCorrector.remove_space(corrector, pos_before)
-          end
-        end
-      end
-
-      private
-
-      def each_missing_space(tokens)
-        tokens.each_cons(2) do |token1, token2|
-          next unless kind(token2)
-          next unless space_missing?(token1, token2)
-          next if space_required_after?(token1)
-
-          pos_before_punctuation = range_between(token1.end_pos, token2.begin_pos)
-
-          yield token2, pos_before_punctuation
-        end
-      end
-
-      def space_missing?(token1, token2)
-        same_line?(token1, token2) && token2.begin_pos > token1.end_pos
-      end
-
-      def space_required_after?(token)
-        token.left_curly_brace? && space_required_after_lcurly?
-      end
-
-      def space_required_after_lcurly?
-        cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
-        style = cfg['EnforcedStyle'] || 'space'
-        style == 'space'
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/naming/block_forwarding.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Naming
-      # In Ruby 3.1, anonymous block forwarding has been added.
-      #
-      # This cop identifies places where `do_something(&block)` can be replaced
-      # by `do_something(&)`.
-      #
-      # It also supports the opposite style by alternative `explicit` option.
-      # You can specify the block variable name for autocorrection with `BlockForwardingName`.
-      # The default variable name is `block`. If the name is already in use, it will not be
-      # autocorrected.
-      #
-      # @example EnforcedStyle: anonymous (default)
-      #
-      #   # bad
-      #   def foo(&block)
-      #     bar(&block)
-      #   end
-      #
-      #   # good
-      #   def foo(&)
-      #     bar(&)
-      #   end
-      #
-      # @example EnforcedStyle: explicit
-      #
-      #   # bad
-      #   def foo(&)
-      #     bar(&)
-      #   end
-      #
-      #   # good
-      #   def foo(&block)
-      #     bar(&block)
-      #   end
-      #
-      class BlockForwarding < Base
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-        extend AutoCorrector
-        extend TargetRubyVersion
-
-        minimum_target_ruby_version 3.1
-
-        MSG = 'Use %<style>s block forwarding.'
-
-        def self.autocorrect_incompatible_with
-          [Lint::AmbiguousOperator]
-        end
-
-        def on_def(node)
-          return if node.arguments.empty?
-
-          last_argument = node.arguments.last
-          return if expected_block_forwarding_style?(node, last_argument)
-
-          register_offense(last_argument, node)
-
-          node.each_descendant(:block_pass) do |block_pass_node|
-            next if block_pass_node.children.first&.sym_type? ||
-                    last_argument.source != block_pass_node.source
-
-            register_offense(block_pass_node, node)
-          end
-        end
-        alias on_defs on_def
-
-        private
-
-        def expected_block_forwarding_style?(node, last_argument)
-          if style == :anonymous
-            !explicit_block_argument?(last_argument) ||
-              use_kwarg_in_method_definition?(node) ||
-              use_block_argument_as_local_variable?(node, last_argument.source[1..])
-          else
-            !anonymous_block_argument?(last_argument)
-          end
-        end
-
-        def use_kwarg_in_method_definition?(node)
-          node.arguments.each_descendant(:kwarg, :kwoptarg).any?
-        end
-
-        def anonymous_block_argument?(node)
-          node.blockarg_type? && node.name.nil?
-        end
-
-        def explicit_block_argument?(node)
-          node.blockarg_type? && !node.name.nil?
-        end
-
-        def register_offense(block_argument, node)
-          add_offense(block_argument, message: format(MSG, style: style)) do |corrector|
-            if style == :anonymous
-              corrector.replace(block_argument, '&')
-
-              arguments = block_argument.parent
-
-              add_parentheses(arguments, corrector) unless arguments.parenthesized_call?
-            else
-              unless use_block_argument_as_local_variable?(node, block_forwarding_name)
-                corrector.replace(block_argument, "&#{block_forwarding_name}")
-              end
-            end
-          end
-        end
-
-        def use_block_argument_as_local_variable?(node, last_argument)
-          return false if node.body.nil?
-
-          node.body.each_descendant(:lvar, :lvasgn).any? do |lvar|
-            !lvar.parent.block_pass_type? && lvar.node_parts[0].to_s == last_argument
-          end
-        end
-
-        def block_forwarding_name
-          cop_config.fetch('BlockForwardingName', 'block')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/naming/constant_name.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Naming
-      # Checks whether constant names are written using
-      # SCREAMING_SNAKE_CASE.
-      #
-      # To avoid false positives, it ignores cases in which we cannot know
-      # for certain the type of value that would be assigned to a constant.
-      #
-      # @example
-      #   # bad
-      #   InchInCm = 2.54
-      #   INCHinCM = 2.54
-      #   Inch_In_Cm = 2.54
-      #
-      #   # good
-      #   INCH_IN_CM = 2.54
-      class ConstantName < Base
-        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'
-        # Use POSIX character classes, so we allow accented characters rather
-        # than just standard ASCII characters
-        SNAKE_CASE = /^[[:digit:][:upper:]_]+$/.freeze
-
-        # @!method class_or_struct_return_method?(node)
-        def_node_matcher :class_or_struct_return_method?, <<~PATTERN
-          (send
-            (const _ {:Class :Struct}) :new
-            ...)
-        PATTERN
-
-        def on_casgn(node)
-          if node.parent&.or_asgn_type?
-            lhs, value = *node.parent
-            _scope, const_name = *lhs
-          else
-            _scope, const_name, value = *node
-          end
-
-          # We cannot know the result of method calls like
-          # NewClass = something_that_returns_a_class
-          # It's also ok to assign a class constant another class constant,
-          # `Class.new(...)` or `Struct.new(...)`
-          # SomeClass = SomeOtherClass
-          # SomeClass = Class.new(...)
-          # SomeClass = Struct.new(...)
-          return if allowed_assignment?(value)
-          return if SNAKE_CASE.match?(const_name)
-
-          add_offense(node.loc.name)
-        end
-
-        private
-
-        def allowed_assignment?(value)
-          (value && %i[block const casgn].include?(value.type)) ||
-            allowed_method_call_on_rhs?(value) ||
-            class_or_struct_return_method?(value) ||
-            allowed_conditional_expression_on_rhs?(value)
-        end
-
-        def allowed_method_call_on_rhs?(node)
-          node&.send_type? &&
-            (node.receiver.nil? || !literal_receiver?(node))
-        end
-
-        # @!method literal_receiver?(node)
-        def_node_matcher :literal_receiver?, <<~PATTERN
-          {(send literal? ...)
-           (send (begin literal?) ...)}
-        PATTERN
-
-        def allowed_conditional_expression_on_rhs?(node)
-          node&.if_type? && contains_constant?(node)
-        end
-
-        def contains_constant?(node)
-          node.branches.compact.any?(&:const_type?)
-        end
-      end
-    end
-  end
-end