study_line 0.1.6 → 0.2.1

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/literal_assignment_in_condition.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for literal assignments in the conditions of `if`, `while`, and `until`.
+      # It emulates the following Ruby warning:
+      #
+      # [source,console]
+      # ----
+      # $ ruby -we 'if x = true; end'
+      # -e:1: warning: found `= literal' in conditional, should be ==
+      # ----
+      #
+      # As a lint cop, it cannot be determined if `==` is appropriate as intended,
+      # therefore this cop does not provide autocorrection.
+      #
+      # @example
+      #
+      #   # bad
+      #   if x = 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x == 42
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if x = y
+      #     do_something
+      #   end
+      #
+      class LiteralAssignmentInCondition < Base
+        MSG = "Don't use literal assignment `= %<literal>s` in conditional, " \
+              'should be `==` or non-literal operand.'
+
+        def on_if(node)
+          traverse_node(node.condition) do |asgn_node|
+            next unless asgn_node.loc.operator
+
+            rhs = asgn_node.to_a.last
+            next if !all_literals?(rhs) || parallel_assignment_with_splat_operator?(rhs)
+
+            range = offense_range(asgn_node, rhs)
+
+            add_offense(range, message: format(MSG, literal: rhs.source))
+          end
+        end
+        alias on_while on_if
+        alias on_until on_if
+
+        private
+
+        def traverse_node(node, &block)
+          yield node if AST::Node::EQUALS_ASSIGNMENTS.include?(node.type)
+
+          node.each_child_node { |child| traverse_node(child, &block) }
+        end
+
+        def all_literals?(node)
+          case node.type
+          when :dstr, :xstr
+            false
+          when :array
+            node.values.all? { |value| all_literals?(value) }
+          when :hash
+            (node.values + node.keys).all? { |item| all_literals?(item) }
+          else
+            node.respond_to?(:literal?) && node.literal?
+          end
+        end
+
+        def parallel_assignment_with_splat_operator?(node)
+          node.array_type? && node.values.first&.splat_type?
+        end
+
+        def offense_range(asgn_node, rhs)
+          asgn_node.loc.operator.join(rhs.source_range.end)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/next_without_accumulator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Don't omit the accumulator when calling `next` in a `reduce` block.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   result = (1..4).reduce(0) do |acc, i|
+      #     next if i.odd?
+      #     acc + i
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   result = (1..4).reduce(0) do |acc, i|
+      #     next acc if i.odd?
+      #     acc + i
+      #   end
+      class NextWithoutAccumulator < Base
+        MSG = 'Use `next` with an accumulator argument in a `reduce`.'
+
+        def on_block(node)
+          on_block_body_of_reduce(node) do |body|
+            void_next = body.each_node(:next).find do |n|
+              n.children.empty? && parent_block_node(n) == node
+            end
+
+            add_offense(void_next) if void_next
+          end
+        end
+        alias on_numblock on_block
+
+        private
+
+        # @!method on_block_body_of_reduce(node)
+        def_node_matcher :on_block_body_of_reduce, <<~PATTERN
+          {
+            (block (call _recv {:reduce :inject} !sym) _blockargs $(begin ...))
+            (numblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
+          }
+        PATTERN
+
+        def parent_block_node(node)
+          node.each_ancestor(:block, :numblock).first
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/non_deterministic_require_order.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # `Dir[...]` and `Dir.glob(...)` do not make any guarantees about
+      # the order in which files are returned. The final order is
+      # determined by the operating system and file system.
+      # This means that using them in cases where the order matters,
+      # such as requiring files, can lead to intermittent failures
+      # that are hard to debug. To ensure this doesn't happen,
+      # always sort the list.
+      #
+      # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
+      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      #
+      # NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
+      #
+      # @safety
+      #   This cop is unsafe in the case where sorting files changes existing
+      #   expected behavior.
+      #
+      # @example
+      #
+      #   # bad
+      #   Dir["./lib/**/*.rb"].each do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir["./lib/**/*.rb"].sort.each do |file|
+      #     require file
+      #   end
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')) do |file|
+      #     require file
+      #   end
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb')).sort.each do |file|
+      #     require file
+      #   end
+      #
+      #   # bad
+      #   Dir['./lib/**/*.rb'].each(&method(:require))
+      #
+      #   # good
+      #   Dir['./lib/**/*.rb'].sort.each(&method(:require))
+      #
+      #   # bad
+      #   Dir.glob(Rails.root.join('test', '*.rb'), &method(:require))
+      #
+      #   # good
+      #   Dir.glob(Rails.root.join('test', '*.rb')).sort.each(&method(:require))
+      #
+      #   # good - Respect intent if `sort` keyword option is specified in Ruby 3.0 or higher.
+      #   Dir.glob(Rails.root.join(__dir__, 'test', '*.rb'), sort: false).each(&method(:require))
+      #
+      class NonDeterministicRequireOrder < Base
+        extend AutoCorrector
+
+        MSG = 'Sort files before requiring them.'
+
+        def on_block(node)
+          return if target_ruby_version >= 3.0
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          loop_variable(node.arguments) do |var_name|
+            return unless var_is_required?(node.body, var_name)
+
+            add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
+          end
+        end
+
+        def on_numblock(node)
+          return if target_ruby_version >= 3.0
+          return unless node.body
+          return unless unsorted_dir_loop?(node.send_node)
+
+          node.argument_list
+              .filter { |argument| var_is_required?(node.body, argument.name) }
+              .each do
+                add_offense(node.send_node) { |corrector| correct_block(corrector, node.send_node) }
+              end
+        end
+
+        def on_block_pass(node)
+          return if target_ruby_version >= 3.0
+          return unless method_require?(node)
+          return unless unsorted_dir_pass?(node.parent)
+
+          parent_node = node.parent
+
+          add_offense(parent_node) do |corrector|
+            if parent_node.last_argument&.block_pass_type?
+              correct_block_pass(corrector, parent_node)
+            else
+              correct_block(corrector, parent_node)
+            end
+          end
+        end
+
+        private
+
+        def correct_block(corrector, node)
+          if unsorted_dir_block?(node)
+            corrector.replace(node, "#{node.source}.sort.each")
+          else
+            source = node.receiver.source
+
+            corrector.replace(node, "#{source}.sort.each")
+          end
+        end
+
+        def correct_block_pass(corrector, node)
+          if unsorted_dir_glob_pass?(node)
+            block_arg = node.last_argument
+
+            corrector.remove(last_arg_range(node))
+            corrector.insert_after(node, ".sort.each(#{block_arg.source})")
+          else
+            corrector.replace(node.loc.selector, 'sort.each')
+          end
+        end
+
+        # Returns range of last argument including comma and whitespace.
+        #
+        # @return [Parser::Source::Range]
+        #
+        def last_arg_range(node)
+          node.last_argument.source_range.with(begin_pos: node.arguments[-2].source_range.end_pos)
+        end
+
+        def unsorted_dir_loop?(node)
+          unsorted_dir_block?(node) || unsorted_dir_each?(node)
+        end
+
+        def unsorted_dir_pass?(node)
+          unsorted_dir_glob_pass?(node) || unsorted_dir_each_pass?(node)
+        end
+
+        # @!method unsorted_dir_block?(node)
+        def_node_matcher :unsorted_dir_block?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...)
+        PATTERN
+
+        # @!method unsorted_dir_each?(node)
+        def_node_matcher :unsorted_dir_each?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each)
+        PATTERN
+
+        # @!method method_require?(node)
+        def_node_matcher :method_require?, <<~PATTERN
+          (block-pass (send nil? :method (sym {:require :require_relative})))
+        PATTERN
+
+        # @!method unsorted_dir_glob_pass?(node)
+        def_node_matcher :unsorted_dir_glob_pass?, <<~PATTERN
+          (send (const {nil? cbase} :Dir) :glob ...
+            (block-pass (send nil? :method (sym {:require :require_relative}))))
+        PATTERN
+
+        # @!method unsorted_dir_each_pass?(node)
+        def_node_matcher :unsorted_dir_each_pass?, <<~PATTERN
+          (send (send (const {nil? cbase} :Dir) {:[] :glob} ...) :each
+            (block-pass (send nil? :method (sym {:require :require_relative}))))
+        PATTERN
+
+        # @!method loop_variable(node)
+        def_node_matcher :loop_variable, <<~PATTERN
+          (args (arg $_))
+        PATTERN
+
+        # @!method var_is_required?(node, name)
+        def_node_search :var_is_required?, <<~PATTERN
+          (send nil? {:require :require_relative} (lvar %1))
+        PATTERN
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/number_conversion.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Warns the usage of unsafe number conversions. Unsafe
+      # number conversion can cause unexpected error if auto type conversion
+      # fails. Cop prefer parsing with number class instead.
+      #
+      # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
+      # if given input that is not numeric (eg. an empty string), whereas
+      # `to_i`, etc. will try to convert regardless of input (``''.to_i => 0``).
+      # As such, this cop is disabled by default because it's not necessarily
+      # always correct to raise if a value is not numeric.
+      #
+      # NOTE: Some values cannot be converted properly using one of the `Kernel`
+      # method (for instance, `Time` and `DateTime` values are allowed by this
+      # cop by default). Similarly, Rails' duration methods do not work well
+      # with `Integer()` and can be allowed with `AllowedMethods`. By default,
+      # there are no methods to allowed.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it is not guaranteed that the
+      #   replacement `Kernel` methods are able to properly handle the
+      #   input if it is not a standard class.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   '10'.to_i
+      #   '10.2'.to_f
+      #   '10'.to_c
+      #   '1/3'.to_r
+      #   ['1', '2', '3'].map(&:to_i)
+      #   foo.try(:to_f)
+      #   bar.send(:to_c)
+      #
+      #   # good
+      #
+      #   Integer('10', 10)
+      #   Float('10.2')
+      #   Complex('10')
+      #   Rational('1/3')
+      #   ['1', '2', '3'].map { |i| Integer(i, 10) }
+      #   foo.try { |i| Float(i) }
+      #   bar.send { |i| Complex(i) }
+      #
+      # @example AllowedMethods: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
+      # @example AllowedMethods: [minutes]
+      #
+      #   # good
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   10.minutes.to_i
+      #
+      # @example AllowedPatterns: ['min*']
+      #
+      #   # good
+      #   10.minutes.to_i
+      #
+      # @example IgnoredClasses: [Time, DateTime] (default)
+      #
+      #   # good
+      #   Time.now.to_datetime.to_i
+      class NumberConversion < Base
+        extend AutoCorrector
+        include AllowedMethods
+        include AllowedPattern
+        include IgnoredNode
+
+        CONVERSION_METHOD_CLASS_MAPPING = {
+          to_i: "#{Integer.name}(%<number_object>s, 10)",
+          to_f: "#{Float.name}(%<number_object>s)",
+          to_c: "#{Complex.name}(%<number_object>s)",
+          to_r: "#{Rational.name}(%<number_object>s)"
+        }.freeze
+        MSG = 'Replace unsafe number conversion with number ' \
+              'class parsing, instead of using ' \
+              '`%<current>s`, use stricter ' \
+              '`%<corrected_method>s`.'
+        CONVERSION_METHODS = %i[Integer Float Complex Rational to_i to_f to_c to_r].freeze
+        METHODS = CONVERSION_METHOD_CLASS_MAPPING.keys.map(&:inspect).join(' ')
+
+        # @!method to_method(node)
+        def_node_matcher :to_method, <<~PATTERN
+          (call $_ ${#{METHODS}})
+        PATTERN
+
+        # @!method to_method_symbol(node)
+        def_node_matcher :to_method_symbol, <<~PATTERN
+          (call _ $_ ${
+            {
+              (sym ${#{METHODS}})
+              (block_pass (sym ${#{METHODS}}))
+            }
+          } ...)
+        PATTERN
+
+        def on_send(node)
+          handle_conversion_method(node)
+          handle_as_symbol(node)
+        end
+        alias on_csend on_send
+
+        private
+
+        def handle_conversion_method(node)
+          to_method(node) do |receiver, to_method|
+            next if receiver.nil? || allow_receiver?(receiver)
+
+            message = format(
+              MSG,
+              current: "#{receiver.source}.#{to_method}",
+              corrected_method: correct_method(node, receiver)
+            )
+            add_offense(node, message: message) do |corrector|
+              next if part_of_ignored_node?(node)
+
+              corrector.replace(node, correct_method(node, node.receiver))
+
+              ignore_node(node)
+            end
+          end
+        end
+
+        def handle_as_symbol(node)
+          to_method_symbol(node) do |receiver, sym_node, to_method|
+            next if receiver.nil? || !node.arguments.one?
+
+            message = format(
+              MSG,
+              current: sym_node.source,
+              corrected_method: correct_sym_method(to_method)
+            )
+            add_offense(node, message: message) do |corrector|
+              remove_parentheses(corrector, node) if node.parenthesized?
+
+              corrector.replace(sym_node, correct_sym_method(to_method))
+            end
+          end
+        end
+
+        def correct_method(node, receiver)
+          format(CONVERSION_METHOD_CLASS_MAPPING[node.method_name], number_object: receiver.source)
+        end
+
+        def correct_sym_method(to_method)
+          body = format(CONVERSION_METHOD_CLASS_MAPPING[to_method], number_object: 'i')
+          "{ |i| #{body} }"
+        end
+
+        def remove_parentheses(corrector, node)
+          corrector.replace(node.loc.begin, ' ')
+          corrector.remove(node.loc.end)
+        end
+
+        def allow_receiver?(receiver)
+          if receiver.numeric_type? || (receiver.send_type? &&
+            (conversion_method?(receiver.method_name) ||
+            allowed_method_name?(receiver.method_name)))
+            true
+          elsif (receiver = top_receiver(receiver))
+            receiver.const_type? && ignored_class?(receiver.const_name)
+          else
+            false
+          end
+        end
+
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
+        def top_receiver(node)
+          receiver = node
+          receiver = receiver.receiver until receiver.receiver.nil?
+          receiver
+        end
+
+        def conversion_method?(method_name)
+          CONVERSION_METHODS.include?(method_name)
+        end
+
+        def ignored_classes
+          cop_config.fetch('IgnoredClasses', [])
+        end
+
+        def ignored_class?(name)
+          ignored_classes.include?(name.to_s)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.60.0/lib/rubocop/cop/lint/redundant_safe_navigation.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant safe navigation calls.
+      # Use cases where a constant, named in camel case for classes and modules is `nil` are rare,
+      # and an offense is not detected when the receiver is a snake case constant.
+      #
+      # For all receivers, the `instance_of?`, `kind_of?`, `is_a?`, `eql?`, `respond_to?`,
+      # and `equal?` methods are checked by default.
+      # These are customizable with `AllowedMethods` option.
+      #
+      # The `AllowedMethods` option specifies nil-safe methods,
+      # in other words, it is a method that is allowed to skip safe navigation.
+      # Note that the `AllowedMethod` option is not an option that specifies methods
+      # for which to suppress (allow) this cop's check.
+      #
+      # In the example below, the safe navigation operator (`&.`) is unnecessary
+      # because `NilClass` has methods like `respond_to?` and `is_a?`.
+      #
+      # @safety
+      #   This cop is unsafe, because autocorrection can change the return type of
+      #   the expression. An offending expression that previously could return `nil`
+      #   will be autocorrected to never return `nil`.
+      #
+      # @example
+      #   # bad
+      #   CamelCaseConst&.do_something
+      #
+      #   # bad
+      #   do_something if attrs&.respond_to?(:[])
+      #
+      #   # good
+      #   do_something if attrs.respond_to?(:[])
+      #
+      #   # bad
+      #   while node&.is_a?(BeginNode)
+      #     node = node.parent
+      #   end
+      #
+      #   # good
+      #   CamelCaseConst.do_something
+      #
+      #   # good
+      #   while node.is_a?(BeginNode)
+      #     node = node.parent
+      #   end
+      #
+      #   # good - without `&.` this will always return `true`
+      #   foo&.respond_to?(:to_a)
+      #
+      #   # bad - for `nil`s conversion methods return default values for the type
+      #   foo&.to_h || {}
+      #   foo&.to_h { |k, v| [k, v] } || {}
+      #   foo&.to_a || []
+      #   foo&.to_i || 0
+      #   foo&.to_f || 0.0
+      #   foo&.to_s || ''
+      #
+      #   # good
+      #   foo.to_h
+      #   foo.to_h { |k, v| [k, v] }
+      #   foo.to_a
+      #   foo.to_i
+      #   foo.to_f
+      #   foo.to_s
+      #
+      # @example AllowedMethods: [nil_safe_method]
+      #   # bad
+      #   do_something if attrs&.nil_safe_method(:[])
+      #
+      #   # good
+      #   do_something if attrs.nil_safe_method(:[])
+      #   do_something if attrs&.not_nil_safe_method(:[])
+      #
+      class RedundantSafeNavigation < Base
+        include AllowedMethods
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant safe navigation detected.'
+        MSG_LITERAL = 'Redundant safe navigation with default literal detected.'
+
+        NIL_SPECIFIC_METHODS = (nil.methods - Object.new.methods).to_set.freeze
+
+        SNAKE_CASE = /\A[[:digit:][:upper:]_]+\z/.freeze
+
+        # @!method respond_to_nil_specific_method?(node)
+        def_node_matcher :respond_to_nil_specific_method?, <<~PATTERN
+          (csend _ :respond_to? (sym %NIL_SPECIFIC_METHODS))
+        PATTERN
+
+        # @!method conversion_with_default?(node)
+        def_node_matcher :conversion_with_default?, <<~PATTERN
+          {
+            (or $(csend _ :to_h) (hash))
+            (or (block $(csend _ :to_h) ...) (hash))
+            (or $(csend _ :to_a) (array))
+            (or $(csend _ :to_i) (int 0))
+            (or $(csend _ :to_f) (float 0.0))
+            (or $(csend _ :to_s) (str empty?))
+          }
+        PATTERN
+
+        # rubocop:disable Metrics/AbcSize
+        def on_csend(node)
+          unless node.receiver.const_type? && !node.receiver.source.match?(SNAKE_CASE)
+            return unless check?(node) && allowed_method?(node.method_name)
+            return if respond_to_nil_specific_method?(node)
+          end
+
+          range = range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
+          add_offense(range) { |corrector| corrector.replace(node.loc.dot, '.') }
+        end
+
+        def on_or(node)
+          conversion_with_default?(node) do |send_node|
+            range = range_between(send_node.loc.dot.begin_pos, node.source_range.end_pos)
+
+            add_offense(range, message: MSG_LITERAL) do |corrector|
+              corrector.replace(send_node.loc.dot, '.')
+
+              range_with_default = range_between(node.lhs.source_range.end.begin_pos,
+                                                 node.source_range.end.end_pos)
+              corrector.remove(range_with_default)
+            end
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def check?(node)
+          parent = node.parent
+          return false unless parent
+
+          condition?(parent, node) ||
+            parent.and_type? ||
+            parent.or_type? ||
+            (parent.send_type? && parent.negation_method?)
+        end
+
+        def condition?(parent, node)
+          (parent.conditional? || parent.post_condition_loop?) && parent.condition == node
+        end
+      end
+    end
+  end
+end