RubyGems - study_line - Versions diffs - 0.1.6 → 0.2.1 - Mend

study_line 0.1.6 → 0.2.1

Files changed (2047) hide show

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/style/operator_method_call.rb DELETED Viewed

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-module RuboCop
-  module Cop
-    module Style
-      # Checks for redundant dot before operator method call.
-      # The target operator methods are `|`, `^`, `&`, `<=>`, `==`, `===`, `=~`, `>`, `>=`, `<`,
-      # `<=`, `<<`, `>>`, `+`, `-`, `*`, `/`, `%`, `**`, `~`, `!`, `!=`, and `!~`.
-      #
-      # @example
-      #
-      #   # bad
-      #   foo.+ bar
-      #   foo.& bar
-      #
-      #   # good
-      #   foo + bar
-      #   foo & bar
-      #
-      class OperatorMethodCall < Base
-        extend AutoCorrector
-        MSG = 'Redundant dot detected.'
-        RESTRICT_ON_SEND = %i[| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ ! != !~].freeze
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-        def on_send(node)
-          return unless (dot = node.loc.dot)
-          return if node.receiver.const_type? || !node.arguments.one?
-          _lhs, _op, rhs = *node
-          return if !rhs || method_call_with_parenthesized_arg?(rhs) || anonymous_forwarding?(rhs)
-          add_offense(dot) do |corrector|
-            wrap_in_parentheses_if_chained(corrector, node)
-            corrector.replace(dot, ' ')
-            selector = node.loc.selector
-            corrector.insert_after(selector, ' ') if selector.end_pos == rhs.source_range.begin_pos
-          end
-        end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
-        private
-        # Checks for an acceptable case of `foo.+(bar).baz`.
-        def method_call_with_parenthesized_arg?(argument)
-          return false unless argument.parent.parent&.send_type?
-          argument.children.first && argument.parent.parenthesized?
-        end
-        def anonymous_forwarding?(argument)
-          return true if argument.forwarded_args_type? || argument.forwarded_restarg_type?
-          return true if argument.hash_type? && argument.children.first&.forwarded_kwrestarg_type?
-          argument.block_pass_type? && argument.source == '&'
-        end
-        def wrap_in_parentheses_if_chained(corrector, node)
-          return unless node.parent&.call_type?
-          return if node.parent.first_argument == node
-          operator = node.loc.selector
-          ParenthesesCorrector.correct(corrector, node)
-          corrector.insert_after(operator, ' ')
-          corrector.wrap(node, '(', ')')
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/style/parallel_assignment.rb DELETED Viewed

@@ -1,300 +0,0 @@
-# frozen_string_literal: true
-require 'tsort'
-module RuboCop
-  module Cop
-    module Style
-      # Checks for simple usages of parallel assignment.
-      # This will only complain when the number of variables
-      # being assigned matched the number of assigning variables.
-      #
-      # @example
-      #   # bad
-      #   a, b, c = 1, 2, 3
-      #   a, b, c = [1, 2, 3]
-      #
-      #   # good
-      #   one, two = *foo
-      #   a, b = foo()
-      #   a, b = b, a
-      #
-      #   a = 1
-      #   b = 2
-      #   c = 3
-      class ParallelAssignment < Base
-        include RescueNode
-        extend AutoCorrector
-        MSG = 'Do not use parallel assignment.'
-        def on_masgn(node)
-          lhs, rhs = *node
-          lhs_elements = *lhs
-          rhs = rhs.body if rhs.rescue_type?
-          rhs_elements = Array(rhs).compact # edge case for one constant
-          return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
-                    allowed_masign?(lhs_elements, rhs_elements)
-          range = node.source_range.begin.join(rhs.source_range.end)
-          add_offense(range) do |corrector|
-            autocorrect(corrector, node, lhs, rhs)
-          end
-        end
-        private
-        def autocorrect(corrector, node, lhs, rhs)
-          left_elements = *lhs
-          right_elements = Array(rhs).compact
-          order = find_valid_order(left_elements, right_elements)
-          correction = assignment_corrector(node, rhs, order)
-          corrector.replace(correction.correction_range, correction.correction)
-        end
-        def allowed_masign?(lhs_elements, rhs_elements)
-          lhs_elements.size != rhs_elements.size ||
-            !find_valid_order(lhs_elements,
-                              add_self_to_getters(rhs_elements))
-        end
-        def allowed_lhs?(node)
-          elements = *node
-          # Account for edge cases using one variable with a comma
-          # E.g.: `foo, = *bar`
-          elements.one? || elements.any?(&:splat_type?)
-        end
-        def allowed_rhs?(node)
-          # Edge case for one constant
-          elements = Array(node).compact
-          # Account for edge case of `Constant::CONSTANT`
-          !node.array_type? || return_of_method_call?(node) || elements.any?(&:splat_type?)
-        end
-        def return_of_method_call?(node)
-          node.block_type? || node.send_type?
-        end
-        def assignment_corrector(node, rhs, order)
-          if node.parent&.rescue_type?
-            _assignment, modifier = *node.parent
-          else
-            _assignment, modifier = *rhs.parent
-          end
-          if modifier_statement?(node.parent)
-            ModifierCorrector.new(node, rhs, modifier, config, order)
-          elsif rescue_modifier?(modifier)
-            RescueCorrector.new(node, rhs, modifier, config, order)
-          else
-            GenericCorrector.new(node, rhs, modifier, config, order)
-          end
-        end
-        def find_valid_order(left_elements, right_elements)
-          # arrange left_elements in an order such that no corresponding right
-          # element refers to a left element earlier in the sequence
-          # this can be done using an algorithm called a "topological sort"
-          # fortunately for us, Ruby's stdlib contains an implementation
-          assignments = left_elements.zip(right_elements)
-          begin
-            AssignmentSorter.new(assignments).tsort
-          rescue TSort::Cyclic
-            nil
-          end
-        end
-        # Converts (send nil :something) nodes to (send (:self) :something).
-        # This makes the sorting algorithm work for expressions such as
-        # `self.a, self.b = b, a`.
-        def add_self_to_getters(right_elements)
-          right_elements.map do |e|
-            implicit_self_getter?(e) { |var| s(:send, s(:self), var) } || e
-          end
-        end
-        # @!method implicit_self_getter?(node)
-        def_node_matcher :implicit_self_getter?, '(send nil? $_)'
-        # Helper class necessitated by silly design of TSort prior to Ruby 2.1
-        # Newer versions have a better API, but that doesn't help us
-        class AssignmentSorter
-          include TSort
-          extend RuboCop::NodePattern::Macros
-          # @!method var_name(node)
-          def_node_matcher :var_name, '{(casgn _ $_) (_ $_)}'
-          # @!method uses_var?(node)
-          def_node_search :uses_var?, '{({lvar ivar cvar gvar} %) (const _ %)}'
-          # @!method matching_calls(node, receiver, method_name)
-          def_node_search :matching_calls, '(send %1 %2 $...)'
-          def initialize(assignments)
-            @assignments = assignments
-          end
-          def tsort_each_node(&block)
-            @assignments.each(&block)
-          end
-          def tsort_each_child(assignment)
-            # yield all the assignments which must come after `assignment`
-            # (due to dependencies on the previous value of the assigned var)
-            my_lhs, _my_rhs = *assignment
-            @assignments.each do |other|
-              _other_lhs, other_rhs = *other
-              next unless dependency?(my_lhs, other_rhs)
-              yield other
-            end
-          end
-          def dependency?(lhs, rhs)
-            uses_var?(rhs, var_name(lhs)) ||
-              (lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs))
-          end
-          # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.
-          # Does `rhs` access the same value which is assigned by `lhs`?
-          def accesses?(rhs, lhs)
-            if lhs.method?(:[]=)
-              # FIXME: Workaround `rubocop:disable` comment for JRuby.
-              # rubocop:disable Performance/RedundantEqualityComparisonBlock
-              matching_calls(rhs, lhs.receiver, :[]).any? { |args| args == lhs.arguments }
-              # rubocop:enable Performance/RedundantEqualityComparisonBlock
-            else
-              access_method = lhs.method_name.to_s.chop.to_sym
-              matching_calls(rhs, lhs.receiver, access_method).any?
-            end
-          end
-        end
-        def modifier_statement?(node)
-          return false unless node
-          node.basic_conditional? && node.modifier_form?
-        end
-        # An internal class for correcting parallel assignment
-        class GenericCorrector
-          include Alignment
-          attr_reader :node, :rhs, :rescue_result, :config
-          def initialize(node, rhs, modifier, config, new_elements)
-            @node = node
-            @rhs = rhs
-            _, _, @rescue_result = *modifier
-            @config = config
-            @new_elements = new_elements
-          end
-          def correction
-            assignment.join("\n#{offset(node)}")
-          end
-          def correction_range
-            node.source_range
-          end
-          protected
-          def assignment
-            @new_elements.map { |lhs, rhs| "#{lhs.source} = #{source(rhs)}" }
-          end
-          private
-          def source(node)
-            if node.str_type? && node.loc.begin.nil?
-              "'#{node.source}'"
-            elsif node.sym_type? && node.loc.begin.nil?
-              ":#{node.source}"
-            else
-              node.source
-            end
-          end
-          def extract_sources(node)
-            node.children.map(&:source)
-          end
-          def cop_config
-            @config.for_cop('Style/ParallelAssignment')
-          end
-        end
-        # An internal class for correcting parallel assignment
-        # protected by rescue
-        class RescueCorrector < GenericCorrector
-          def correction
-            # If the parallel assignment uses a rescue modifier and it is the
-            # only contents of a method, then we want to make use of the
-            # implicit begin
-            if rhs.parent.parent.parent&.def_type?
-              super + def_correction(rescue_result)
-            else
-              begin_correction(rescue_result)
-            end
-          end
-          def correction_range
-            rhs.parent.parent.source_range
-          end
-          private
-          def def_correction(rescue_result)
-            "\nrescue" \
-              "\n#{offset(node)}#{rescue_result.source}"
-          end
-          def begin_correction(rescue_result)
-            "begin\n" \
-              "#{indentation(node)}" \
-              "#{assignment.join("\n#{indentation(node)}")}" \
-              "\n#{offset(node)}rescue\n" \
-              "#{indentation(node)}#{rescue_result.source}" \
-              "\n#{offset(node)}end"
-          end
-        end
-        # An internal class for correcting parallel assignment
-        # guarded by if, unless, while, or until
-        class ModifierCorrector < GenericCorrector
-          def correction
-            parent = node.parent
-            "#{modifier_range(parent).source}\n" \
-              "#{indentation(node)}" \
-              "#{assignment.join("\n#{indentation(node)}")}" \
-              "\n#{offset(node)}end"
-          end
-          def correction_range
-            node.parent.source_range
-          end
-          private
-          def modifier_range(node)
-            Parser::Source::Range.new(node.source_range.source_buffer,
-                                      node.loc.keyword.begin_pos,
-                                      node.source_range.end_pos)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/style/parentheses_around_condition.rb DELETED Viewed

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-module RuboCop
-  module Cop
-    module Style
-      # Checks for the presence of superfluous parentheses around the
-      # condition of if/unless/while/until.
-      #
-      # `AllowSafeAssignment` option for safe assignment.
-      # By safe assignment we mean putting parentheses around
-      # an assignment to indicate "I know I'm using an assignment
-      # as a condition. It's not a mistake."
-      #
-      # @example
-      #   # bad
-      #   x += 1 while (x < 10)
-      #   foo unless (bar || baz)
-      #
-      #   if (x > 10)
-      #   elsif (x < 3)
-      #   end
-      #
-      #   # good
-      #   x += 1 while x < 10
-      #   foo unless bar || baz
-      #
-      #   if x > 10
-      #   elsif x < 3
-      #   end
-      #
-      # @example AllowSafeAssignment: true (default)
-      #   # good
-      #   foo unless (bar = baz)
-      #
-      # @example AllowSafeAssignment: false
-      #   # bad
-      #   foo unless (bar = baz)
-      #
-      # @example AllowInMultilineConditions: false (default)
-      #   # bad
-      #   if (x > 10 &&
-      #      y > 10)
-      #   end
-      #
-      #   # good
-      #    if x > 10 &&
-      #       y > 10
-      #    end
-      #
-      # @example AllowInMultilineConditions: true
-      #   # good
-      #   if (x > 10 &&
-      #      y > 10)
-      #   end
-      #
-      class ParenthesesAroundCondition < Base
-        include SafeAssignment
-        include Parentheses
-        include RangeHelp
-        extend AutoCorrector
-        def on_if(node)
-          return if node.ternary?
-          process_control_op(node)
-        end
-        def on_while(node)
-          process_control_op(node)
-        end
-        alias on_until on_while
-        private
-        # @!method control_op_condition(node)
-        def_node_matcher :control_op_condition, <<~PATTERN
-          (begin $_ $...)
-        PATTERN
-        def process_control_op(node)
-          cond = node.condition
-          control_op_condition(cond) do |first_child, rest_children|
-            return if semicolon_separated_expressions?(first_child, rest_children)
-            return if modifier_op?(first_child)
-            return if parens_allowed?(cond)
-            message = message(cond)
-            add_offense(cond, message: message) do |corrector|
-              ParenthesesCorrector.correct(corrector, cond)
-            end
-          end
-        end
-        def semicolon_separated_expressions?(first_exp, rest_exps)
-          return false unless (second_exp = rest_exps.first)
-          range = range_between(first_exp.source_range.end_pos, second_exp.source_range.begin_pos)
-          range.source.include?(';')
-        end
-        def modifier_op?(node)
-          return false if node.if_type? && node.ternary?
-          return true if node.rescue_type?
-          node.basic_conditional? && node.modifier_form?
-        end
-        def message(node)
-          kw = node.parent.keyword
-          article = kw == 'while' ? 'a' : 'an'
-          "Don't use parentheses around the condition of #{article} `#{kw}`."
-        end
-        def parens_allowed?(node)
-          parens_required?(node) ||
-            (safe_assignment?(node) && safe_assignment_allowed?) ||
-            (node.multiline? && allow_multiline_conditions?)
-        end
-        def allow_multiline_conditions?
-          cop_config['AllowInMultilineConditions']
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.2.0/gems/rubocop-1.57.2/lib/rubocop/cop/style/redundant_argument.rb DELETED Viewed

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-module RuboCop
-  module Cop
-    module Style
-      # Checks for a redundant argument passed to certain methods.
-      #
-      # NOTE: This cop is limited to methods with single parameter.
-      #
-      # Method names and their redundant arguments can be configured like this:
-      #
-      # [source,yaml]
-      # ----
-      # Methods:
-      #   join: ''
-      #   sum: 0
-      #   split: ' '
-      #   chomp: "\n"
-      #   chomp!: "\n"
-      #   foo: 2
-      # ----
-      #
-      # @safety
-      #   This cop is unsafe because of the following limitations:
-      #
-      #   1. This cop matches by method names only and hence cannot tell apart
-      #      methods with same name in different classes.
-      #   2. This cop may be unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
-      #      That depends on the nature of the target methods, of course. For example, the default
-      #      argument to join is `$OUTPUT_FIELD_SEPARATOR` (or `$,`) rather than `''`, and if that
-      #      global is changed, `''` is no longer a redundant argument.
-      #
-      # @example
-      #   # bad
-      #   array.join('')
-      #   [1, 2, 3].join("")
-      #   array.sum(0)
-      #   exit(true)
-      #   exit!(false)
-      #   string.split(" ")
-      #   "first\nsecond".split(" ")
-      #   string.chomp("\n")
-      #   string.chomp!("\n")
-      #   A.foo(2)
-      #
-      #   # good
-      #   array.join
-      #   [1, 2, 3].join
-      #   array.sum
-      #   exit
-      #   exit!
-      #   string.split
-      #   "first second".split
-      #   string.chomp
-      #   string.chomp!
-      #   A.foo
-      class RedundantArgument < Base
-        include RangeHelp
-        extend AutoCorrector
-        MSG = 'Argument %<arg>s is redundant because it is implied by default.'
-        NO_RECEIVER_METHODS = %i[exit exit!].freeze
-        def on_send(node)
-          return if !NO_RECEIVER_METHODS.include?(node.method_name) && node.receiver.nil?
-          return if node.arguments.count != 1
-          return unless redundant_argument?(node)
-          offense_range = argument_range(node)
-          message = format(MSG, arg: node.arguments.first.source)
-          add_offense(offense_range, message: message) do |corrector|
-            corrector.remove(offense_range)
-          end
-        end
-        private
-        def redundant_argument?(node)
-          redundant_argument = redundant_arg_for_method(node.method_name.to_s)
-          return false if redundant_argument.nil?
-          node.arguments.first == redundant_argument
-        end
-        def redundant_arg_for_method(method_name)
-          arg = cop_config['Methods'].fetch(method_name) { return }
-          @mem ||= {}
-          @mem[method_name] ||= parse(arg.inspect).ast
-        end
-        def argument_range(node)
-          if node.parenthesized?
-            range_between(node.loc.begin.begin_pos, node.loc.end.end_pos)
-          else
-            range_with_surrounding_space(node.first_argument.source_range, newlines: false)
-          end
-        end
-      end
-    end
-  end
-end