super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for redundant access modifiers, including those with no
+      # code, those which are repeated, those which are on top-level, and
+      # leading `public` modifiers in a class or module body.
+      # Conditionally-defined methods are considered as always being defined,
+      # and thus access modifiers guarding such methods are not redundant.
+      #
+      # This cop has `ContextCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create its own context in the module's current access context.
+      #
+      # It also has `MethodCreatingMethods` option. The default setting value
+      # is an empty array that means no method is specified.
+      # This setting is an array of methods which, when called, are known to
+      # create other methods in the module's current access context.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     public # this is redundant (default access is public)
+      #
+      #     def method
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     # The following is redundant (methods defined on the class'
+      #     # singleton class are not affected by the private modifier)
+      #     private
+      #
+      #     def self.method3
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     protected
+      #
+      #     define_method(:method2) do
+      #     end
+      #
+      #     protected # this is redundant (repeated from previous modifier)
+      #
+      #     [1,2,3].each do |i|
+      #       define_method("foo#{i}") do
+      #       end
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class Foo
+      #     private # this is redundant (no following methods are defined)
+      #   end
+      #
+      #   # bad
+      #   private # this is useless (access modifiers have no effect on top-level)
+      #
+      #   def method
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     private # this is not redundant (a method is defined)
+      #
+      #     def method2
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     # The following is not redundant (conditionally defined methods are
+      #     # considered as always defining a method)
+      #     private
+      #
+      #     if condition?
+      #       def method
+      #       end
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     protected # this is not redundant (a method is defined)
+      #
+      #     define_method(:method2) do
+      #     end
+      #   end
+      #
+      # @example ContextCreatingMethods: concerning
+      #   # Lint/UselessAccessModifier:
+      #   #   ContextCreatingMethods:
+      #   #     - concerning
+      #
+      #   # good
+      #   require 'active_support/concern'
+      #   class Foo
+      #     concerning :Bar do
+      #       def some_public_method
+      #       end
+      #
+      #       private
+      #
+      #       def some_private_method
+      #       end
+      #     end
+      #
+      #     # this is not redundant because `concerning` created its own context
+      #     private
+      #
+      #     def some_other_private_method
+      #     end
+      #   end
+      #
+      # @example MethodCreatingMethods: delegate
+      #   # Lint/UselessAccessModifier:
+      #   #   MethodCreatingMethods:
+      #   #     - delegate
+      #
+      #   # good
+      #   require 'active_support/core_ext/module/delegation'
+      #   class Foo
+      #     # this is not redundant because `delegate` creates methods
+      #     private
+      #
+      #     delegate :method_a, to: :method_b
+      #   end
+      class UselessAccessModifier < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Useless `%<current>s` access modifier.'
+
+        def on_class(node)
+          check_node(node.body)
+        end
+        alias on_module on_class
+        alias on_sclass on_class
+
+        def on_block(node)
+          return unless eval_call?(node) || included_block?(node)
+
+          check_node(node.body)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_begin(node)
+          return if node.parent
+
+          node.child_nodes.each do |child|
+            next unless child.send_type? && access_modifier?(child)
+
+            # This call always registers an offense for access modifier `child.method_name`
+            check_send_node(child, child.method_name, true)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          range = range_by_whole_lines(node.source_range, include_final_newline: true)
+
+          corrector.remove(range)
+        end
+
+        # @!method static_method_definition?(node)
+        def_node_matcher :static_method_definition?, <<~PATTERN
+          {def (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)}
+        PATTERN
+
+        # @!method dynamic_method_definition?(node)
+        def_node_matcher :dynamic_method_definition?, <<~PATTERN
+          {(send nil? :define_method ...) (any_block (send nil? :define_method ...) ...)}
+        PATTERN
+
+        # @!method class_or_instance_eval?(node)
+        def_node_matcher :class_or_instance_eval?, <<~PATTERN
+          (any_block (send _ {:class_eval :instance_eval}) ...)
+        PATTERN
+
+        def check_node(node)
+          return if node.nil?
+
+          if node.begin_type?
+            check_scope(node)
+          elsif node.send_type? && node.bare_access_modifier?
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
+          end
+        end
+
+        def access_modifier?(node)
+          node.bare_access_modifier? || node.method?(:private_class_method)
+        end
+
+        def check_scope(node)
+          cur_vis, unused = check_child_nodes(node, nil, :public)
+          return unless unused
+
+          add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+            autocorrect(corrector, unused)
+          end
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def check_child_nodes(node, unused, cur_vis)
+          node.child_nodes.each do |child|
+            if child.send_type? && access_modifier?(child)
+              cur_vis, unused = check_send_node(child, cur_vis, unused)
+            elsif child.block_type? && included_block?(child)
+              next
+            elsif method_definition?(child)
+              unused = nil
+            elsif start_of_new_scope?(child)
+              check_scope(child)
+            elsif !child.defs_type?
+              cur_vis, unused = check_child_nodes(child, unused, cur_vis)
+            end
+          end
+
+          [cur_vis, unused]
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+        def check_send_node(node, cur_vis, unused)
+          if node.bare_access_modifier?
+            check_new_visibility(node, unused, node.method_name, cur_vis)
+          elsif node.method?(:private_class_method) && !node.arguments?
+            add_offense(node, message: format(MSG, current: node.method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
+            [cur_vis, unused]
+          end
+        end
+
+        def check_new_visibility(node, unused, new_vis, cur_vis)
+          # does this modifier just repeat the existing visibility?
+          if new_vis == cur_vis
+            add_offense(node, message: format(MSG, current: cur_vis)) do |corrector|
+              autocorrect(corrector, node)
+            end
+          else
+            # was the previous modifier never applied to any defs?
+            if unused
+              add_offense(unused, message: format(MSG, current: cur_vis)) do |corrector|
+                autocorrect(corrector, unused)
+              end
+            end
+            # once we have already warned about a certain modifier, don't
+            # warn again even if it is never applied to any method defs
+            unused = node
+          end
+
+          [new_vis, unused]
+        end
+
+        def included_block?(block_node)
+          active_support_extensions_enabled? && block_node.method?(:included)
+        end
+
+        def method_definition?(child)
+          static_method_definition?(child) ||
+            dynamic_method_definition?(child) ||
+            any_method_definition?(child)
+        end
+
+        def any_method_definition?(child)
+          cop_config.fetch('MethodCreatingMethods', []).any? do |m|
+            # Some users still have `"included"` in their `MethodCreatingMethods` configurations,
+            # so to prevent Ruby method redefinition warnings let's just skip this value.
+            next if m == 'included'
+
+            matcher_name = :"#{m}_method?"
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<~PATTERN
+                {def (send nil? :#{m} ...)}
+              PATTERN
+            end
+
+            public_send(matcher_name, child)
+          end
+        end
+
+        def start_of_new_scope?(child)
+          child.type?(:module, :class, :sclass) || eval_call?(child)
+        end
+
+        def eval_call?(child)
+          class_or_instance_eval?(child) ||
+            child.class_constructor? ||
+            any_context_creating_methods?(child)
+        end
+
+        def any_context_creating_methods?(child)
+          # Some users still have `"included"` in their `ContextCreatingMethods` configurations,
+          # so to prevent Ruby method redefinition warnings let's just skip this value.
+          cop_config.fetch('ContextCreatingMethods', []).any? do |m|
+            next if m == 'included'
+
+            matcher_name = :"#{m}_block?"
+            unless respond_to?(matcher_name)
+              self.class.def_node_matcher matcher_name, <<~PATTERN
+                (any_block (send {nil? const} {:#{m}} ...) ...)
+              PATTERN
+            end
+
+            public_send(matcher_name, child)
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/useless_assignment.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for every useless assignment to local variable in every
+      # scope.
+      # The basic idea for this cop was from the warning of `ruby -cw`:
+      #
+      # [source,console]
+      # ----
+      # assigned but unused variable - foo
+      # ----
+      #
+      # Currently this cop has advanced logic that detects unreferenced
+      # reassignments and properly handles varied cases such as branch, loop,
+      # rescue, ensure, etc.
+      #
+      # This cop's autocorrection avoids cases like `a ||= 1` because removing assignment from
+      # operator assignment can cause `NameError` if this assignment has been used to declare
+      # a local variable. For example, replacing `a ||= 1` with `a || 1` may cause
+      # "undefined local variable or method `a' for main:Object (NameError)".
+      #
+      # NOTE: Given the assignment `foo = 1, bar = 2`, removing unused variables
+      # can lead to a syntax error, so this case is not autocorrected.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method
+      #     some_var = 1
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     some_var = 1
+      #     do_something(some_var)
+      #   end
+      class UselessAssignment < Base
+        extend AutoCorrector
+
+        MSG = 'Useless assignment to variable - `%<variable>s`.'
+
+        def self.joining_forces
+          VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value { |variable| check_for_unused_assignments(variable) }
+        end
+
+        def check_for_unused_assignments(variable)
+          return if variable.should_be_unused?
+
+          variable.assignments.reverse_each do |assignment|
+            check_for_unused_assignment(variable, assignment)
+          end
+        end
+
+        def check_for_unused_assignment(variable, assignment)
+          assignment_node = assignment.node
+
+          return if ignored_assignment?(variable, assignment_node, assignment)
+
+          message = message_for_useless_assignment(assignment)
+          range = offense_range(assignment)
+
+          add_offense(range, message: message) do |corrector|
+            next if uncorrectable_assignment?(assignment_node)
+
+            autocorrect(corrector, assignment)
+          end
+
+          ignore_node(assignment_node) if chained_assignment?(assignment_node)
+        end
+
+        # Autocorrect is skipped when removing a variable would cause a syntax error
+        # (`x = 1, y = 2`), or where rewriting `x ||= 1`/`x &&= 1` to `x = 1` would raise
+        # `NameError` because the variable is not declared before the operator assignment.
+        def uncorrectable_assignment?(assignment_node)
+          sequential_assignment?(assignment_node) ||
+            assignment_node.parent&.or_asgn_type? ||
+            assignment_node.parent&.and_asgn_type?
+        end
+
+        def ignored_assignment?(variable, assignment_node, assignment)
+          assignment.used? || part_of_ignored_node?(assignment_node) ||
+            variable_in_loop_condition?(assignment_node, variable)
+        end
+
+        def message_for_useless_assignment(assignment)
+          variable = assignment.variable
+
+          format(MSG, variable: variable.name) + message_specification(assignment, variable).to_s
+        end
+
+        def offense_range(assignment)
+          if assignment.regexp_named_capture?
+            assignment.node.children.first.source_range
+          else
+            assignment.node.loc.name
+          end
+        end
+
+        def sequential_assignment?(node)
+          if node.lvasgn_type? && node.expression&.array_type? &&
+             node.each_descendant.any?(&:assignment?)
+            return true
+          end
+          return false unless node.parent
+
+          sequential_assignment?(node.parent)
+        end
+
+        def chained_assignment?(node)
+          return true if node.lvasgn_type? && node.expression&.send_type?
+
+          node.respond_to?(:expression) && node.expression&.lvasgn_type?
+        end
+
+        def message_specification(assignment, variable)
+          if assignment.multiple_assignment?
+            multiple_assignment_message(variable.name)
+          elsif assignment.operator_assignment?
+            operator_assignment_message(variable.scope, assignment)
+          else
+            similar_name_message(variable)
+          end
+        end
+
+        def multiple_assignment_message(variable_name)
+          " Use `_` or `_#{variable_name}` as a variable name to indicate " \
+            "that it won't be used."
+        end
+
+        def operator_assignment_message(scope, assignment)
+          return_value_node = return_value_node_of_scope(scope)
+          return unless assignment.meta_assignment_node.equal?(return_value_node)
+
+          " Use `#{assignment.operator.delete_suffix('=')}` instead of `#{assignment.operator}`."
+        end
+
+        def similar_name_message(variable)
+          variable_like_names = collect_variable_like_names(variable.scope)
+          similar_name = NameSimilarity.find_similar_name(variable.name, variable_like_names)
+          " Did you mean `#{similar_name}`?" if similar_name
+        end
+
+        # TODO: More precise handling (rescue, ensure, nested begin, etc.)
+        def return_value_node_of_scope(scope)
+          body_node = scope.body_node
+
+          if body_node.begin_type?
+            body_node.children.last
+          else
+            body_node
+          end
+        end
+
+        def collect_variable_like_names(scope)
+          names = scope.each_node.with_object(Set.new) do |node, set|
+            set << node.method_name if variable_like_method_invocation?(node)
+          end
+
+          variable_names = scope.variables.each_value.map(&:name)
+          names.merge(variable_names)
+        end
+
+        def variable_like_method_invocation?(node)
+          return false unless node.send_type?
+
+          node.receiver.nil? && !node.arguments?
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, assignment)
+          if assignment.exception_assignment?
+            remove_exception_assignment_part(corrector, assignment.node)
+          elsif assignment.multiple_assignment? || assignment.rest_assignment? ||
+                assignment.for_assignment?
+            rename_variable_with_underscore(corrector, assignment.node)
+          elsif assignment.operator_assignment?
+            remove_trailing_character_from_operator(corrector, assignment.node)
+          elsif assignment.regexp_named_capture?
+            replace_named_capture_group_with_non_capturing_group(corrector, assignment.node,
+                                                                 assignment.variable.name)
+          else
+            remove_local_variable_assignment_part(corrector, assignment.node)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def remove_exception_assignment_part(corrector, node)
+          range = node.parent.children.first&.source_range || node.parent.location.keyword
+
+          corrector.remove(range.end.join(node.source_range.end))
+        end
+
+        def rename_variable_with_underscore(corrector, node)
+          corrector.replace(node, '_')
+        end
+
+        def remove_trailing_character_from_operator(corrector, node)
+          corrector.remove(node.parent.location.operator.end.adjust(begin_pos: -1))
+        end
+
+        def replace_named_capture_group_with_non_capturing_group(corrector, node, variable_name)
+          corrector.replace(
+            node.children.first,
+            node.children.first.source.sub(/\(\?<#{variable_name}>/, '(?:')
+          )
+        end
+
+        def remove_local_variable_assignment_part(corrector, node)
+          corrector.remove(node.loc.name.begin.join(node.expression.source_range.begin))
+        end
+
+        def variable_in_loop_condition?(assignment_node, variable)
+          return false if assignment_node.each_ancestor(:any_def).any?
+
+          loop_node = assignment_node.each_ancestor.find do |ancestor|
+            ancestor.type?(*VariableForce::LOOP_TYPES)
+          end
+
+          return false unless loop_node.respond_to?(:condition)
+
+          condition_node = loop_node.condition
+          variable_name = variable.name
+
+          return true if condition_node.lvar_type? && condition_node.children.first == variable_name
+
+          condition_node.each_descendant(:lvar) do |lvar_node|
+            return true if lvar_node.children.first == variable_name
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/lint/useless_constant_scoping.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for useless constant scoping. Private constants must be defined using
+      # `private_constant`. Even if `private` access modifier is used, it is public scope despite
+      # its appearance.
+      #
+      # It does not support autocorrection due to behavior change and multiple ways to fix it.
+      # Or a public constant may be intended.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     private
+      #     PRIVATE_CONST = 42
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PRIVATE_CONST = 42
+      #     private_constant :PRIVATE_CONST
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     PUBLIC_CONST = 42 # If private scope is not intended.
+      #   end
+      #
+      class UselessConstantScoping < Base
+        MSG = 'Useless `private` access modifier for constant scope.'
+
+        # @!method private_constants(node)
+        def_node_matcher :private_constants, <<~PATTERN
+          (send nil? :private_constant $...)
+        PATTERN
+
+        def on_casgn(node)
+          return unless after_private_modifier?(node.left_siblings)
+          return if private_constantize?(node.right_siblings, node.name)
+
+          add_offense(node)
+        end
+
+        private
+
+        def after_private_modifier?(left_siblings)
+          access_modifier_candidates = left_siblings.compact.select do |left_sibling|
+            left_sibling.respond_to?(:bare_access_modifier?) && left_sibling.bare_access_modifier?
+          end
+
+          return false if access_modifier_candidates.empty?
+
+          access_modifier_candidates.last.command?(:private)
+        end
+
+        def private_constantize?(right_siblings, const_value)
+          private_constant_arguments = right_siblings.map { |node| private_constants(node) }
+
+          private_constant_values = private_constant_arguments.flatten.filter_map do |constant|
+            constant.value.to_sym if constant.respond_to?(:value)
+          end
+
+          private_constant_values.include?(const_value)
+        end
+      end
+    end
+  end
+end