RubyGems - study_line - Versions diffs - 0.2.7 → 0.2.8 - Mend

study_line 0.2.7 → 0.2.8

Files changed (2184) hide show

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

@@ -1,252 +0,0 @@
-# frozen_string_literal: true
-module RuboCop
-  module Cop
-    module Style
-      # If the branch of a conditional consists solely of a conditional node,
-      # its conditions can be combined with the conditions of the outer branch.
-      # This helps to keep the nesting level from getting too deep.
-      #
-      # @example
-      #   # bad
-      #   if condition_a
-      #     if condition_b
-      #       do_something
-      #     end
-      #   end
-      #
-      #   # bad
-      #   if condition_b
-      #     do_something
-      #   end if condition_a
-      #
-      #   # good
-      #   if condition_a && condition_b
-      #     do_something
-      #   end
-      #
-      # @example AllowModifier: false (default)
-      #   # bad
-      #   if condition_a
-      #     do_something if condition_b
-      #   end
-      #
-      #   # bad
-      #   if condition_b
-      #     do_something
-      #   end if condition_a
-      #
-      # @example AllowModifier: true
-      #   # good
-      #   if condition_a
-      #     do_something if condition_b
-      #   end
-      #
-      #   # good
-      #   if condition_b
-      #     do_something
-      #   end if condition_a
-      class SoleNestedConditional < Base
-        include RangeHelp
-        extend AutoCorrector
-        MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
-        def self.autocorrect_incompatible_with
-          [Style::NegatedIf, Style::NegatedUnless]
-        end
-        def on_if(node)
-          return if node.ternary? || node.else? || node.elsif?
-          if_branch = node.if_branch
-          return if use_variable_assignment_in_condition?(node.condition, if_branch)
-          return unless offending_branch?(node, if_branch)
-          message = format(MSG, conditional_type: node.keyword)
-          add_offense(if_branch.loc.keyword, message: message) do |corrector|
-            autocorrect(corrector, node, if_branch)
-          end
-        end
-        private
-        def use_variable_assignment_in_condition?(condition, if_branch)
-          assigned_variables = assigned_variables(condition)
-          assigned_variables && if_branch&.if_type? &&
-            assigned_variables.include?(if_branch.condition.source)
-        end
-        def assigned_variables(condition)
-          assigned_variables = condition.assignment? ? [condition.children.first.to_s] : []
-          assigned_variables + condition.descendants.select(&:assignment?).map do |node|
-            node.children.first.to_s
-          end
-        end
-        def offending_branch?(node, branch)
-          return false unless branch
-          branch.if_type? &&
-            !branch.else? &&
-            !branch.ternary? &&
-            !((node.modifier_form? || branch.modifier_form?) && allow_modifier?)
-        end
-        def autocorrect(corrector, node, if_branch)
-          if node.condition.or_type? || node.condition.assignment?
-            corrector.wrap(node.condition, '(', ')')
-          end
-          if outer_condition_modify_form?(node, if_branch)
-            autocorrect_outer_condition_modify_form(corrector, node, if_branch)
-          else
-            autocorrect_outer_condition_basic(corrector, node, if_branch)
-          end
-        end
-        def autocorrect_outer_condition_basic(corrector, node, if_branch)
-          correct_from_unless_to_if(corrector, node) if node.unless?
-          outer_condition = node.condition
-          correct_outer_condition(corrector, outer_condition)
-          and_operator = if_branch.unless? ? ' && !' : ' && '
-          if if_branch.modifier_form?
-            correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
-          else
-            correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
-            correct_for_comment(corrector, node, if_branch)
-          end
-        end
-        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
-          correct_from_unless_to_if(corrector, if_branch, is_modify_form: true) if if_branch.unless?
-          correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
-        end
-        def correct_from_unless_to_if(corrector, node, is_modify_form: false)
-          corrector.replace(node.loc.keyword, 'if')
-          insert_bang(corrector, node, is_modify_form)
-        end
-        def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
-          condition = if_branch.condition
-          corrector.insert_after(outer_condition, "#{and_operator}#{replace_condition(condition)}")
-          range = range_between(if_branch.loc.keyword.begin_pos, condition.source_range.end_pos)
-          corrector.remove(range_with_surrounding_space(range, newlines: false))
-          corrector.remove(if_branch.loc.keyword)
-        end
-        def correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
-          range = range_between(
-            node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
-          )
-          corrector.replace(range, and_operator)
-          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
-          wrap_condition(corrector, if_branch.condition)
-        end
-        def wrap_condition(corrector, condition)
-          # Handle `send` and `block` nodes that need to be wrapped in parens
-          # FIXME: autocorrection prevents syntax errors by wrapping the entire node in parens,
-          #        but wrapping the argument list would be a more ergonomic correction.
-          node_to_check = condition&.block_type? ? condition.send_node : condition
-          return unless wrap_condition?(node_to_check)
-          corrector.wrap(condition, '(', ')')
-        end
-        def correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
-          condition = if_branch.condition
-          corrector.insert_before(condition,
-                                  "#{'!' if node.unless?}#{replace_condition(node.condition)} && ")
-          corrector.remove(node.condition)
-          corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
-          corrector.replace(if_branch.loc.keyword, 'if')
-        end
-        def correct_for_comment(corrector, node, if_branch)
-          comments = processed_source.ast_with_comments[if_branch].select do |comment|
-            comment.loc.line < if_branch.condition.first_line
-          end
-          comment_text = comments.map(&:text).join("\n") << "\n"
-          corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
-        end
-        def correct_outer_condition(corrector, condition)
-          return unless require_parentheses?(condition)
-          end_pos = condition.loc.selector.end_pos
-          begin_pos = condition.first_argument.source_range.begin_pos
-          return if end_pos > begin_pos
-          range = range_between(end_pos, begin_pos)
-          corrector.remove(range)
-          corrector.insert_after(range, '(')
-          corrector.insert_after(condition.last_argument, ')')
-        end
-        def insert_bang(corrector, node, is_modify_form)
-          condition = node.condition
-          if (condition.send_type? && condition.comparison_method? && !condition.parenthesized?) ||
-             (is_modify_form && wrap_condition?(condition))
-            corrector.wrap(node.condition, '!(', ')')
-          elsif condition.and_type?
-            insert_bang_for_and(corrector, node)
-          else
-            corrector.insert_before(condition, '!')
-          end
-        end
-        def insert_bang_for_and(corrector, node)
-          lhs, rhs = *node
-          if lhs.and_type?
-            insert_bang_for_and(corrector, lhs)
-            corrector.insert_before(rhs, '!') if rhs
-          else
-            corrector.insert_before(lhs, '!')
-            corrector.insert_before(rhs, '!')
-          end
-        end
-        def require_parentheses?(condition)
-          condition.call_type? && !condition.arguments.empty? && !condition.parenthesized? &&
-            !condition.comparison_method?
-        end
-        def arguments_range(node)
-          range_between(
-            node.first_argument.source_range.begin_pos, node.last_argument.source_range.end_pos
-          )
-        end
-        def wrap_condition?(node)
-          node.and_type? || node.or_type? ||
-            (node.call_type? && node.arguments.any? && !node.parenthesized?)
-        end
-        def replace_condition(condition)
-          wrap_condition?(condition) ? "(#{condition.source})" : condition.source
-        end
-        def allow_modifier?
-          cop_config['AllowModifier']
-        end
-        def outer_condition_modify_form?(node, if_branch)
-          node.condition.source_range.begin_pos > if_branch.condition.source_range.begin_pos
-        end
-      end
-    end
-  end
-end

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

@@ -1,260 +0,0 @@
-# frozen_string_literal: true
-module RuboCop
-  module Cop
-    module Style
-      # Looks for uses of Perl-style global variables.
-      # Correcting to global variables in the 'English' library
-      # will add a require statement to the top of the file if
-      # enabled by RequireEnglish config.
-      #
-      # @safety
-      #   Autocorrection is marked as unsafe because if `RequireEnglish` is not
-      #   true, replacing perl-style variables with english variables will break.
-      #
-      # @example EnforcedStyle: use_english_names (default)
-      #   # good
-      #   require 'English' # or this could be in another file.
-      #
-      #   puts $LOAD_PATH
-      #   puts $LOADED_FEATURES
-      #   puts $PROGRAM_NAME
-      #   puts $ERROR_INFO
-      #   puts $ERROR_POSITION
-      #   puts $FIELD_SEPARATOR # or $FS
-      #   puts $OUTPUT_FIELD_SEPARATOR # or $OFS
-      #   puts $INPUT_RECORD_SEPARATOR # or $RS
-      #   puts $OUTPUT_RECORD_SEPARATOR # or $ORS
-      #   puts $INPUT_LINE_NUMBER # or $NR
-      #   puts $LAST_READ_LINE
-      #   puts $DEFAULT_OUTPUT
-      #   puts $DEFAULT_INPUT
-      #   puts $PROCESS_ID # or $PID
-      #   puts $CHILD_STATUS
-      #   puts $LAST_MATCH_INFO
-      #   puts $IGNORECASE
-      #   puts $ARGV # or ARGV
-      #
-      # @example EnforcedStyle: use_perl_names
-      #   # good
-      #   puts $:
-      #   puts $"
-      #   puts $0
-      #   puts $!
-      #   puts $@
-      #   puts $;
-      #   puts $,
-      #   puts $/
-      #   puts $\
-      #   puts $.
-      #   puts $_
-      #   puts $>
-      #   puts $<
-      #   puts $$
-      #   puts $?
-      #   puts $~
-      #   puts $=
-      #   puts $*
-      #
-      # @example EnforcedStyle: use_builtin_english_names
-      #
-      # Like `use_perl_names` but allows builtin global vars.
-      #
-      #   # good
-      #   puts $LOAD_PATH
-      #   puts $LOADED_FEATURES
-      #   puts $PROGRAM_NAME
-      #   puts ARGV
-      #   puts $:
-      #   puts $"
-      #   puts $0
-      #   puts $!
-      #   puts $@
-      #   puts $;
-      #   puts $,
-      #   puts $/
-      #   puts $\
-      #   puts $.
-      #   puts $_
-      #   puts $>
-      #   puts $<
-      #   puts $$
-      #   puts $?
-      #   puts $~
-      #   puts $=
-      #   puts $*
-      #
-      class SpecialGlobalVars < Base
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-        include RequireLibrary
-        extend AutoCorrector
-        MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
-                   'module (don\'t forget to require it) or `%<regular>s` over ' \
-                   '`%<global>s`.'
-        MSG_ENGLISH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
-                      'module (don\'t forget to require it) over `%<global>s`.'
-        MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'
-        ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
-          :$: => [:$LOAD_PATH],
-          :$" => [:$LOADED_FEATURES],
-          :$0 => [:$PROGRAM_NAME],
-          :$! => [:$ERROR_INFO],
-          :$@ => [:$ERROR_POSITION],
-          :$; => %i[$FIELD_SEPARATOR $FS],
-          :$, => %i[$OUTPUT_FIELD_SEPARATOR $OFS],
-          :$/ => %i[$INPUT_RECORD_SEPARATOR $RS],
-          :$\ => %i[$OUTPUT_RECORD_SEPARATOR $ORS],
-          :$. => %i[$INPUT_LINE_NUMBER $NR],
-          :$_ => [:$LAST_READ_LINE],
-          :$> => [:$DEFAULT_OUTPUT],
-          :$< => [:$DEFAULT_INPUT],
-          :$$ => %i[$PROCESS_ID $PID],
-          :$? => [:$CHILD_STATUS],
-          :$~ => [:$LAST_MATCH_INFO],
-          :$= => [:$IGNORECASE],
-          :$* => %i[$ARGV ARGV]
-        }
-        # Anything *not* in this set is provided by the English library.
-        NON_ENGLISH_VARS = Set.new(%i[$LOAD_PATH $LOADED_FEATURES $PROGRAM_NAME ARGV]).freeze
-        PERL_VARS = ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }.to_h
-        ENGLISH_VARS.merge!(ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
-        PERL_VARS.merge!(PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
-        BUILTIN_VARS = PERL_VARS.merge(
-          NON_ENGLISH_VARS
-            .select { |v| v.to_s.start_with?('$') }
-            .flat_map { |v| [[v, [v]], PERL_VARS[v].flat_map { |a| [a, [v]] }] }
-            .to_h
-        )
-        ENGLISH_VARS.each_value(&:freeze).freeze
-        PERL_VARS.each_value(&:freeze).freeze
-        BUILTIN_VARS.each_value(&:freeze).freeze
-        STYLE_VARS_MAP = {
-          use_english_names: ENGLISH_VARS,
-          use_perl_names: PERL_VARS,
-          use_builtin_english_names: BUILTIN_VARS
-        }.freeze
-        LIBRARY_NAME = 'English'
-        def on_new_investigation
-          super
-          @required_english = false
-        end
-        def on_gvar(node)
-          global_var, = *node
-          return unless (preferred = preferred_names(global_var))
-          if preferred.include?(global_var)
-            correct_style_detected
-          else
-            style_detected(matching_styles(global_var))
-            add_offense(node, message: message(global_var)) do |corrector|
-              autocorrect(corrector, node, global_var)
-            end
-          end
-        end
-        def message(global_var)
-          if style == :use_english_names
-            format_english_message(global_var)
-          else
-            format(MSG_REGULAR, prefer: preferred_names(global_var).first, global: global_var)
-          end
-        end
-        def autocorrect(corrector, node, global_var)
-          node = node.parent while node.parent&.begin_type? && node.parent.children.one?
-          if should_require_english?(global_var)
-            ensure_required(corrector, node, LIBRARY_NAME)
-            @required_english = true
-          end
-          corrector.replace(node, replacement(node, global_var))
-        end
-        private
-        def format_english_message(global_var)
-          regular, english = ENGLISH_VARS[global_var].partition do |var|
-            NON_ENGLISH_VARS.include? var
-          end
-          format_message(english, regular, global_var)
-        end
-        def format_message(english, regular, global)
-          if regular.empty?
-            format(MSG_ENGLISH, prefer: format_list(english), global: global)
-          elsif english.empty?
-            format(MSG_REGULAR, prefer: format_list(regular), global: global)
-          else
-            format(MSG_BOTH,
-                   prefer: format_list(english),
-                   regular: format_list(regular),
-                   global: global)
-          end
-        end
-        # For now, we assume that lists are 2 items or less. Easy grammar!
-        def format_list(items)
-          items.join('` or `')
-        end
-        def replacement(node, global_var)
-          parent_type = node.parent&.type
-          preferred_name = preferred_names(global_var).first
-          return preferred_name.to_s unless %i[dstr xstr regexp].include?(parent_type)
-          return english_name_replacement(preferred_name, node) if style == :use_english_names
-          "##{preferred_name}"
-        end
-        def preferred_names(global)
-          vars = STYLE_VARS_MAP.fetch(style) do
-            raise ArgumentError, "Invalid style: #{style.inspect}"
-          end
-          vars[global]
-        end
-        def matching_styles(global)
-          STYLE_VARS_MAP.filter_map do |style, vars|
-            style if vars.values.flatten(1).include? global
-          end
-        end
-        def english_name_replacement(preferred_name, node)
-          return "\#{#{preferred_name}}" if node.begin_type?
-          "{#{preferred_name}}"
-        end
-        def add_require_english?
-          cop_config['RequireEnglish']
-        end
-        def should_require_english?(global_var)
-          style == :use_english_names &&
-            add_require_english? &&
-            !@required_english &&
-            !NON_ENGLISH_VARS.include?(preferred_names(global_var).first)
-        end
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-module RuboCop
-  module Cop
-    module Style
-      # Check for parentheses around stabby lambda arguments.
-      # There are two different styles. Defaults to `require_parentheses`.
-      #
-      # @example EnforcedStyle: require_parentheses (default)
-      #   # bad
-      #   ->a,b,c { a + b + c }
-      #
-      #   # good
-      #   ->(a,b,c) { a + b + c}
-      #
-      # @example EnforcedStyle: require_no_parentheses
-      #   # bad
-      #   ->(a,b,c) { a + b + c }
-      #
-      #   # good
-      #   ->a,b,c { a + b + c}
-      class StabbyLambdaParentheses < Base
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
-        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments with parentheses.'
-        def on_send(node)
-          return unless stabby_lambda_with_args?(node)
-          return unless redundant_parentheses?(node) || missing_parentheses?(node)
-          arguments = node.block_node.arguments
-          add_offense(arguments) do |corrector|
-            case style
-            when :require_parentheses
-              missing_parentheses_corrector(corrector, arguments)
-            when :require_no_parentheses
-              unwanted_parentheses_corrector(corrector, arguments)
-            end
-          end
-        end
-        private
-        def missing_parentheses?(node)
-          style == :require_parentheses && !parentheses?(node)
-        end
-        def redundant_parentheses?(node)
-          style == :require_no_parentheses && parentheses?(node)
-        end
-        def message(_node)
-          style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
-        end
-        def missing_parentheses_corrector(corrector, node)
-          corrector.wrap(node, '(', ')')
-        end
-        def unwanted_parentheses_corrector(corrector, node)
-          args_loc = node.loc
-          corrector.replace(args_loc.begin, '')
-          corrector.remove(args_loc.end)
-        end
-        def stabby_lambda_with_args?(node)
-          node.lambda_literal? && node.block_node.arguments?
-        end
-        def parentheses?(node)
-          node.block_node.arguments.loc.begin
-        end
-      end
-    end
-  end
-end