super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # > ABC is .. a software size metric .. computed by counting the number
+        # > of assignments, branches and conditions for a section of code.
+        # > http://c2.com/cgi/wiki?AbcMetric
+        #
+        # We separate the *calculator* from the *cop* so that the calculation,
+        # the formula itself, is easier to test.
+        class AbcSizeCalculator
+          include IteratingBlock
+          include RepeatedCsendDiscount
+          prepend RepeatedAttributeDiscount
+
+          # > Branch -- an explicit forward program branch out of scope -- a
+          # > function call, class method call ..
+          # > http://c2.com/cgi/wiki?AbcMetric
+          BRANCH_NODES = %i[send csend yield].freeze
+
+          # > Condition -- a logical/Boolean test, == != <= >= < > else case
+          # > default try catch ? and unary conditionals.
+          # > http://c2.com/cgi/wiki?AbcMetric
+          CONDITION_NODES = CyclomaticComplexity::COUNTED_NODES.freeze
+
+          private_constant :BRANCH_NODES, :CONDITION_NODES
+
+          def self.calculate(node, discount_repeated_attributes: false)
+            new(node, discount_repeated_attributes: discount_repeated_attributes).calculate
+          end
+
+          def initialize(node)
+            @assignment = 0
+            @branch = 0
+            @condition = 0
+            @node = node
+            reset_repeated_csend
+          end
+
+          def calculate
+            visit_depth_last(@node) { |child| calculate_node(child) }
+
+            [
+              Math.sqrt((@assignment**2) + (@branch**2) + (@condition**2)).round(2),
+              "<#{@assignment}, #{@branch}, #{@condition}>"
+            ]
+          end
+
+          def evaluate_branch_nodes(node)
+            if node.comparison_method?
+              @condition += 1
+            else
+              @branch += 1
+              @condition += 1 if node.csend_type? && !discount_for_repeated_csend?(node)
+            end
+          end
+
+          def evaluate_condition_node(node)
+            @condition += 1 if else_branch?(node)
+            @condition += 1
+          end
+
+          def else_branch?(node)
+            %i[case if].include?(node.type) && node.else? && node.loc.else.is?('else')
+          end
+
+          private
+
+          def visit_depth_last(node, &block)
+            node.each_child_node { |child| visit_depth_last(child, &block) }
+            yield node
+          end
+
+          def calculate_node(node)
+            @assignment += 1 if assignment?(node)
+
+            if branch?(node)
+              evaluate_branch_nodes(node)
+            elsif condition?(node)
+              evaluate_condition_node(node)
+            end
+          end
+
+          def assignment?(node)
+            if node.masgn_type? || node.shorthand_asgn?
+              compound_assignment(node)
+              return false
+            end
+
+            node.for_type? ||
+              (node.respond_to?(:setter_method?) && node.setter_method?) ||
+              simple_assignment?(node) ||
+              argument?(node)
+          end
+
+          def compound_assignment(node)
+            # Methods setter cannot be detected for multiple assignments
+            # and shorthand assigns, so we'll count them here instead
+            children = node.masgn_type? ? node.assignments : node.children
+
+            will_be_miscounted = children.count do |child|
+              child.respond_to?(:setter_method?) && !child.setter_method?
+            end
+            @assignment += will_be_miscounted
+          end
+
+          def simple_assignment?(node)
+            if !node.equals_asgn?
+              false
+            elsif node.lvasgn_type?
+              reset_on_lvasgn(node)
+              capturing_variable?(node.children.first)
+            else
+              true
+            end
+          end
+
+          def capturing_variable?(name)
+            name && !name.start_with?('_')
+          end
+
+          def branch?(node)
+            BRANCH_NODES.include?(node.type)
+          end
+
+          def argument?(node)
+            node.argument_type? && capturing_variable?(node.children.first)
+          end
+
+          def condition?(node)
+            return false if iterating_block?(node) == false
+
+            CONDITION_NODES.include?(node.type)
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # Helps to calculate code length for the provided node.
+        class CodeLengthCalculator
+          extend NodePattern::Macros
+          include Util
+
+          FOLDABLE_TYPES = %i[array hash heredoc method_call].freeze
+          CLASSLIKE_TYPES = %i[class module].freeze
+          private_constant :FOLDABLE_TYPES, :CLASSLIKE_TYPES
+
+          def initialize(node, processed_source, count_comments: false, foldable_types: [])
+            @node = node
+            @processed_source = processed_source
+            @count_comments = count_comments
+            @foldable_checks = build_foldable_checks(foldable_types)
+            @foldable_types = normalize_foldable_types(foldable_types)
+          end
+
+          def calculate
+            length = code_length(@node)
+            return length if @foldable_types.empty?
+
+            each_top_level_descendant(@node, @foldable_types) do |descendant|
+              next unless foldable_node?(descendant)
+
+              descendant_length = code_length(descendant)
+              length = length - descendant_length + 1
+              # Subtract length of opening and closing brace if method argument omits hash braces.
+              length -= omit_length(descendant) if descendant.hash_type? && !descendant.braces?
+            end
+
+            length
+          end
+
+          private
+
+          def build_foldable_checks(types) # rubocop:disable Metrics/MethodLength
+            types.map do |type|
+              case type
+              when :array
+                lambda(&:array_type?)
+              when :hash
+                lambda(&:hash_type?)
+              when :heredoc
+                ->(node) { heredoc_node?(node) }
+              when :method_call
+                lambda(&:call_type?)
+              else
+                raise Warning, "Unknown foldable type: #{type.inspect}. " \
+                               "Valid foldable types are: #{FOLDABLE_TYPES.join(', ')}."
+              end
+            end
+          end
+
+          def normalize_foldable_types(types)
+            types.push(:str, :dstr) if types.delete(:heredoc)
+            types.push(:send, :csend) if types.delete(:method_call)
+            types
+          end
+
+          def code_length(node) # rubocop:disable Metrics/MethodLength
+            if classlike_node?(node)
+              classlike_code_length(node)
+            elsif heredoc_node?(node)
+              heredoc_length(node)
+            else
+              body = extract_body(node)
+              return 0 unless body
+
+              source =
+                if node_with_heredoc?(body)
+                  source_from_node_with_heredoc(body)
+                else
+                  body.source.lines
+                end
+
+              source.count { |line| !irrelevant_line?(line) }
+            end
+          end
+
+          def heredoc_node?(node)
+            node.respond_to?(:heredoc?) && node.heredoc?
+          end
+
+          def classlike_code_length(node)
+            return 0 if namespace_module?(node)
+
+            body_line_numbers = line_range(node).to_a[1...-1]
+
+            target_line_numbers = body_line_numbers -
+                                  line_numbers_of_inner_nodes(node, :module, :class)
+
+            target_line_numbers.reduce(0) do |length, line_number|
+              source_line = @processed_source[line_number]
+              next length if irrelevant_line?(source_line)
+
+              length + 1
+            end
+          end
+
+          def namespace_module?(node)
+            classlike_node?(node.body)
+          end
+
+          def line_numbers_of_inner_nodes(node, *types)
+            line_numbers = Set.new
+
+            node.each_descendant(*types) do |inner_node|
+              line_range = line_range(inner_node)
+              line_numbers.merge(line_range)
+            end
+
+            line_numbers.to_a
+          end
+
+          def heredoc_length(node)
+            lines = node.loc.heredoc_body.source.lines
+            lines.count { |line| !irrelevant_line?(line) } + 2
+          end
+
+          def each_top_level_descendant(node, types, &block)
+            node.each_child_node do |child|
+              next if classlike_node?(child)
+
+              if types.include?(child.type)
+                yield child
+              else
+                each_top_level_descendant(child, types, &block)
+              end
+            end
+          end
+
+          def classlike_node?(node)
+            CLASSLIKE_TYPES.include?(node&.type)
+          end
+
+          def foldable_node?(node)
+            @foldable_checks.any? { |check| check.call(node) }
+          end
+
+          def extract_body(node)
+            case node.type
+            when :class, :module, :sclass, :block, :numblock, :itblock, :def, :defs
+              node.body
+            when :casgn
+              extract_body(node.expression)
+            else
+              node
+            end
+          end
+
+          # Returns true for lines that shall not be included in the count.
+          def irrelevant_line?(source_line)
+            source_line.blank? || (!count_comments? && comment_line?(source_line))
+          end
+
+          def count_comments?
+            @count_comments
+          end
+
+          def omit_length(descendant)
+            parent = descendant.parent
+            return 0 if another_args?(parent)
+            return 0 unless parenthesized?(parent)
+
+            [
+              parent.loc.begin.end_pos != descendant.source_range.begin_pos,
+              parent.loc.end.begin_pos != descendant.source_range.end_pos
+            ].count(true)
+          end
+
+          def parenthesized?(node)
+            node.call_type? && node.parenthesized?
+          end
+
+          def another_args?(node)
+            node.call_type? && node.arguments.count > 1
+          end
+
+          def node_with_heredoc?(node)
+            node.each_descendant(:str, :dstr).any? { |descendant| heredoc_node?(descendant) }
+          end
+
+          def source_from_node_with_heredoc(node)
+            last_line = -1
+            node.each_descendant do |descendant|
+              next unless descendant.source
+
+              descendant_last_line =
+                if heredoc_node?(descendant)
+                  descendant.loc.heredoc_end.line
+                else
+                  descendant.last_line
+                end
+
+              last_line = [last_line, descendant_last_line].max
+            end
+            @processed_source[(node.first_line - 1)..(last_line - 1)]
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/metrics/utils/iterating_block.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # Used to identify iterating blocks like `.map{}` and `.map(&:...)`
+        module IteratingBlock
+          enumerable = %i[
+            all? any? chain chunk chunk_while collect collect_concat count cycle
+            detect drop drop_while each each_cons each_entry each_slice
+            each_with_index each_with_object entries filter filter_map find
+            find_all find_index flat_map grep grep_v group_by inject lazy map
+            max max_by min min_by minmax minmax_by none? one? partition reduce
+            reject reverse_each select slice_after slice_before slice_when sort
+            sort_by sum take take_while tally to_h uniq zip
+          ]
+
+          enumerator = %i[with_index with_object]
+
+          array = %i[
+            bsearch bsearch_index collect! combination d_permutation delete_if
+            each_index keep_if map! permutation product reject! repeat
+            repeated_combination select! sort sort! sort_by sort_by
+          ]
+
+          hash = %i[
+            each_key each_pair each_value fetch fetch_values has_key? merge
+            merge! transform_keys transform_keys! transform_values
+            transform_values!
+          ]
+
+          KNOWN_ITERATING_METHODS = (Set.new(enumerable) + enumerator + array + hash).freeze
+
+          # Returns the name of the method called with a block
+          # if node is a block node, or a block-pass node.
+          def block_method_name(node)
+            case node.type
+            when :block
+              node.method_name
+            when :block_pass
+              node.parent.method_name
+            end
+          end
+
+          # Returns true only when name is a known iterating type (e.g. :each, :transform_values).
+          def iterating_method?(name)
+            KNOWN_ITERATING_METHODS.include? name
+          end
+
+          # Returns nil if node is neither a block node or a block-pass node.
+          # Otherwise returns true/false if method call is a known iterating call
+          def iterating_block?(node)
+            name = block_method_name(node)
+            name && iterating_method?(name)
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/metrics/utils/repeated_attribute_discount.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # @api private
+        #
+        # Identifies repetitions `{c}send` calls with no arguments:
+        #
+        #   foo.bar
+        #   foo.bar # => repeated
+        #   foo.bar.baz.qux # => inner send repeated
+        #   foo.bar.baz.other # => both inner send repeated
+        #   foo.bar(2) # => not repeated
+        #
+        # It also invalidates sequences if a receiver is reassigned:
+        #
+        #   xx.foo.bar
+        #   xx.foo.baz      # => inner send repeated
+        #   self.xx = any   # => invalidates everything so far
+        #   xx.foo.baz      # => no repetition
+        #   self.xx.foo.baz # => all repeated
+        #
+        module RepeatedAttributeDiscount
+          extend NodePattern::Macros
+          include RuboCop::AST::Sexp
+
+          VAR_SETTER_TO_GETTER = {
+            lvasgn: :lvar,
+            ivasgn: :ivar,
+            cvasgn: :cvar,
+            gvasgn: :gvar
+          }.freeze
+
+          # Plug into the calculator
+          def initialize(node, discount_repeated_attributes: false)
+            super(node)
+            return unless discount_repeated_attributes
+
+            self_attributes = {} # Share hash for `(send nil? :foo)` and `(send (self) :foo)`
+            @known_attributes = { s(:self) => self_attributes, nil => self_attributes }
+            # example after running `obj = foo.bar; obj.baz.qux`
+            # { nil => {foo: {bar: {}}},
+            #   s(self) => same hash ^,
+            #   s(:lvar, :obj) => {baz: {qux: {}}}
+            # }
+          end
+
+          def discount_repeated_attributes?
+            defined?(@known_attributes)
+          end
+
+          def evaluate_branch_nodes(node)
+            return if discount_repeated_attributes? && discount_repeated_attribute?(node)
+
+            super
+          end
+
+          def calculate_node(node)
+            update_repeated_attribute(node) if discount_repeated_attributes?
+            super
+          end
+
+          private
+
+          # @!method attribute_call?(node)
+          def_node_matcher :attribute_call?, <<~PATTERN
+            (call _receiver _method # and no parameters
+            )
+          PATTERN
+
+          def discount_repeated_attribute?(send_node)
+            return false unless attribute_call?(send_node)
+
+            repeated = true
+            find_attributes(send_node) do |hash, lookup|
+              return false if hash.nil?
+
+              repeated = false
+              hash[lookup] = {}
+            end
+
+            repeated
+          end
+
+          def update_repeated_attribute(node)
+            return unless (receiver, method = setter_to_getter(node))
+
+            calls = find_attributes(receiver) { return }
+            if method # e.g. `self.foo = 42`
+              calls.delete(method)
+            else      # e.g. `var = 42`
+              calls.clear
+            end
+          end
+
+          # @!method root_node?(node)
+          def_node_matcher :root_node?, <<~PATTERN
+            { nil? | self               # e.g. receiver of `my_method` or `self.my_attr`
+            | lvar | ivar | cvar | gvar # e.g. receiver of `var.my_method`
+            | const }                   # e.g. receiver of `MyConst.foo.bar`
+          PATTERN
+
+          # Returns the "known_attributes" for the `node` by walking the receiver tree
+          # If at any step the subdirectory does not exist, it is yielded with the
+          # associated key (method_name)
+          # If the node is not a series of `(c)send` calls with no arguments,
+          # then `nil` is yielded
+          def find_attributes(node, &block)
+            if attribute_call?(node)
+              calls = find_attributes(node.receiver, &block)
+              value = node.method_name
+            elsif root_node?(node)
+              calls = @known_attributes
+              value = node
+            else
+              return yield nil
+            end
+
+            calls.fetch(value) { yield [calls, value] }
+          end
+
+          # @returns `[receiver, method | nil]` for the given setter `node`
+          # or `nil` if it is not a setter.
+          def setter_to_getter(node)
+            if (type = VAR_SETTER_TO_GETTER[node.type])
+              # (lvasgn :my_var (int 42)) => [(lvar my_var), nil]
+              [s(type, node.children.first), nil]
+            elsif node.shorthand_asgn? # (or-asgn (send _receiver :foo) _value)
+              # (or-asgn (send _receiver :foo) _value) => [_receiver, :foo]
+              node.children.first.children
+            elsif node.respond_to?(:setter_method?) && node.setter_method?
+              # (send _receiver :foo= (int 42) ) => [_receiver, :foo]
+              method_name = node.method_name[0...-1].to_sym
+              [node.receiver, method_name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      module Utils
+        # @api private
+        #
+        # Identifies repetitions `&.` on the same variable:
+        #
+        #  my_var&.foo
+        #  my_var&.bar # => repeated
+        #  my_var = baz # => reset
+        #  my_var&.qux # => not repeated
+        module RepeatedCsendDiscount
+          def reset_repeated_csend
+            @repeated_csend = {}
+          end
+
+          def discount_for_repeated_csend?(csend_node)
+            receiver = csend_node.receiver
+
+            return false unless receiver.lvar_type?
+
+            var_name = receiver.children.first
+            seen = @repeated_csend.fetch(var_name) do
+              @repeated_csend[var_name] = csend_node
+              return false
+            end
+
+            !seen.equal?(csend_node)
+          end
+
+          def reset_on_lvasgn(node)
+            var_name = node.children.first
+            @repeated_csend.delete(var_name)
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/migration/department_name.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# Lint/RedundantCopDisableDirective needs to be disabled so as
+# to be able to provide examples of rubocop:disable comments.
+# rubocop:disable Lint/RedundantCopDisableDirective
+module RuboCop
+  module Cop
+    module Migration
+      # Checks that cop names in rubocop:disable comments are given with
+      # department name.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable AbcSize
+      #
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
+      class DepartmentName < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Department name is missing.'
+
+        DISABLE_COMMENT_FORMAT = /\A(# *rubocop *: *((dis|en)able|todo) +)(.*)/.freeze
+
+        # The token that makes up a disable comment.
+        # The allowed specification for comments after `# rubocop: disable` is
+        # `DepartmentName/CopName` or` all`.
+        DISABLING_COPS_CONTENT_TOKEN = %r{[A-Za-z]+/[A-Za-z]+|all}.freeze
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next if comment.text !~ DISABLE_COMMENT_FORMAT
+
+            offset = Regexp.last_match(1).length
+
+            Regexp.last_match(4).scan(/[^,]+|\W+/) do |name|
+              trimmed_name = name.strip
+
+              unless valid_content_token?(trimmed_name)
+                check_cop_name(trimmed_name, comment, offset)
+              end
+
+              break if contain_unexpected_character_for_department_name?(name)
+
+              offset += name.length
+            end
+          end
+        end
+
+        private
+
+        def disable_comment_offset
+          Regexp.last_match(1).length
+        end
+
+        def check_cop_name(name, comment, offset)
+          start = comment.source_range.begin_pos + offset
+          range = range_between(start, start + name.length)
+
+          add_offense(range) do |corrector|
+            cop_name = range.source
+            qualified_cop_name = Registry.global.qualified_cop_name(cop_name, nil, warn: false)
+
+            unless qualified_cop_name.include?('/')
+              qualified_cop_name = qualified_legacy_cop_name(cop_name)
+            end
+
+            corrector.replace(range, qualified_cop_name)
+          end
+        end
+
+        def valid_content_token?(content_token)
+          /\W+/.match?(content_token) ||
+            DISABLING_COPS_CONTENT_TOKEN.match?(content_token) ||
+            Registry.global.department?(content_token)
+        end
+
+        def contain_unexpected_character_for_department_name?(name)
+          name.match?(%r{[^A-Za-z/, ]})
+        end
+
+        def qualified_legacy_cop_name(cop_name)
+          legacy_cop_names = RuboCop::ConfigObsoletion.legacy_cop_names
+
+          legacy_cop_names.detect { |legacy_cop_name| legacy_cop_name.split('/')[1] == cop_name }
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/RedundantCopDisableDirective