super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/style/guard_clause.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Use a guard clause instead of wrapping the code inside a conditional
+      # expression
+      #
+      # A condition with an `elsif` or `else` branch is allowed unless
+      # one of `return`, `break`, `next`, `raise`, or `fail` is used
+      # in the body of the conditional expression.
+      #
+      # NOTE: Autocorrect works in most cases except with if-else statements
+      #   that contain logical operators such as `foo || raise('exception')`
+      #
+      # @example
+      #   # bad
+      #   def test
+      #     if something
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   def test
+      #     return unless something
+      #
+      #     work
+      #   end
+      #
+      #   # also good
+      #   def test
+      #     work if something
+      #   end
+      #
+      #   # bad
+      #   if something
+      #     raise 'exception'
+      #   else
+      #     ok
+      #   end
+      #
+      #   # good
+      #   raise 'exception' if something
+      #   ok
+      #
+      #   # bad
+      #   define_method(:test) do
+      #     if something
+      #       work
+      #     end
+      #   end
+      #
+      #   # good
+      #   define_method(:test) do
+      #     return unless something
+      #
+      #     work
+      #   end
+      #
+      #   # also good
+      #   define_method(:test) do
+      #     work if something
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: false (default)
+      #   # bad
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
+      #   end
+      #
+      # @example AllowConsecutiveConditionals: true
+      #   # good
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     if bar?
+      #       work
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def test
+      #     if foo?
+      #       work
+      #     end
+      #
+      #     do_something
+      #
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
+      #   end
+      #
+      class GuardClause < Base
+        extend AutoCorrector
+        include RangeHelp
+        include MinBodyLength
+        include StatementModifier
+
+        MSG = 'Use a guard clause (`%<example>s`) instead of wrapping the ' \
+              'code inside a conditional expression.'
+
+        def on_def(node)
+          body = node.body
+
+          return unless body
+
+          check_ending_body(body)
+        end
+        alias on_defs on_def
+
+        def on_block(node)
+          return unless node.method?(:define_method) || node.method?(:define_singleton_method)
+
+          on_def(node)
+        end
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_if(node)
+          return if accepted_form?(node)
+
+          if (guard_clause = node.if_branch&.guard_clause?)
+            kw = node.loc.keyword.source
+            guard = :if
+          elsif (guard_clause = node.else_branch&.guard_clause?)
+            kw = node.inverse_keyword
+            guard = :else
+          else
+            return
+          end
+
+          guard = nil if and_or_guard_clause?(guard_clause)
+
+          register_offense(node, guard_clause_source(guard_clause), kw, guard)
+        end
+
+        private
+
+        def check_ending_body(body)
+          return if body.nil?
+
+          if body.if_type?
+            check_ending_if(body)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
+          end
+        end
+
+        def check_ending_if(node)
+          return if accepted_form?(node, ending: true) || !min_body_length?(node)
+          return if allowed_consecutive_conditionals? &&
+                    consecutive_conditionals?(node.parent, node)
+
+          register_offense(node, 'return', node.inverse_keyword)
+
+          check_ending_body(node.if_branch)
+        end
+
+        def consecutive_conditionals?(parent, node)
+          parent.each_child_node.inject(false) do |if_type, child|
+            break if_type if node == child
+
+            child.if_type?
+          end
+        end
+
+        def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = nil)
+          condition, = node.node_parts
+          example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
+          if too_long_for_single_line?(node, example)
+            return if trivial?(node)
+
+            example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
+            replacement = <<~RUBY.chomp
+              #{conditional_keyword} #{condition.source}
+                #{scope_exiting_keyword}
+              end
+            RUBY
+          end
+
+          add_offense(node.loc.keyword, message: format(MSG, example: example)) do |corrector|
+            next if node.else? && guard.nil?
+
+            autocorrect(corrector, node, condition, replacement || example, guard)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, node, condition, replacement, guard)
+          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
+
+          if_branch = node.if_branch
+          else_branch = node.else_branch
+
+          corrector.replace(node.loc.begin, "\n") if node.then?
+
+          if (if_heredoc = find_heredoc_argument(if_branch))
+            autocorrect_heredoc_argument(corrector, node, if_heredoc, else_branch, guard)
+          elsif (else_heredoc = find_heredoc_argument(else_branch))
+            autocorrect_heredoc_argument(corrector, node, else_heredoc, if_branch, guard)
+          else
+            corrector.remove(node.loc.end)
+            return unless node.else?
+
+            corrector.remove(node.loc.else)
+            corrector.remove(range_of_branch_to_remove(node, guard))
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def heredoc?(argument)
+          argument.respond_to?(:heredoc?) && argument.heredoc?
+        end
+
+        def find_heredoc_argument(node)
+          return unless node
+
+          node = node.children.first while node.begin_type?
+          return node if heredoc?(node)
+          return unless node.call_type?
+
+          node.arguments.reverse_each do |argument|
+            heredoc_argument = find_heredoc_argument(argument)
+            return heredoc_argument if heredoc_argument
+          end
+
+          find_heredoc_argument(node.receiver)
+        end
+
+        def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard)
+          remove_whole_lines(corrector, node.loc.end)
+          return unless node.else?
+
+          if leave_branch
+            remove_whole_lines(corrector, leave_branch.source_range)
+            corrector.insert_after(heredoc_node.loc.heredoc_end, "\n#{leave_branch.source}")
+          end
+
+          remove_whole_lines(corrector, node.loc.else)
+          remove_whole_lines(corrector, range_of_branch_to_remove(node, guard))
+        end
+
+        def range_of_branch_to_remove(node, guard)
+          branch = case guard
+                   when :if then node.if_branch
+                   when :else then node.else_branch
+                   end
+
+          branch.source_range
+        end
+
+        def guard_clause_source(guard_clause)
+          if and_or_guard_clause?(guard_clause)
+            guard_clause.parent.source
+          else
+            guard_clause.source
+          end
+        end
+
+        def and_or_guard_clause?(guard_clause)
+          parent = guard_clause.parent
+          parent.operator_keyword?
+        end
+
+        def too_long_for_single_line?(node, example)
+          max = max_line_length
+          max && node.source_range.column + example.length > max
+        end
+
+        def accepted_form?(node, ending: false)
+          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
+        end
+
+        def trivial?(node)
+          return false unless node.if_branch
+
+          node.branches.one? && !node.if_branch.if_type? && !node.if_branch.begin_type?
+        end
+
+        def accepted_if?(node, ending)
+          return true if node.modifier_form? || node.ternary? || node.elsif_conditional? ||
+                         assigned_lvar_used_in_if_branch?(node)
+
+          if ending
+            node.else?
+          else
+            !node.else? || node.elsif?
+          end
+        end
+
+        def assigned_lvar_used_in_if_branch?(node)
+          return false unless (if_branch = node.if_branch)
+
+          assigned_lvars_in_condition = node.condition.each_descendant(:lvasgn).map do |lvasgn|
+            lvar_name, = *lvasgn
+            lvar_name.to_s
+          end
+          used_lvars_in_branch = if_branch.each_descendant(:lvar).map(&:source) || []
+
+          (assigned_lvars_in_condition & used_lvars_in_branch).any?
+        end
+
+        def remove_whole_lines(corrector, range)
+          corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+        end
+
+        def allowed_consecutive_conditionals?
+          cop_config.fetch('AllowConsecutiveConditionals', false)
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/style/hash_as_last_array_item.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for presence or absence of braces around hash literal as a last
+      # array item depending on configuration.
+      #
+      # NOTE: This cop will ignore arrays where multiple items are all hashes,
+      # regardless of `EnforcedStyle`.
+      #
+      # [source,ruby]
+      # ----
+      # [{ one: 1 }, { two: 2 }]
+      # ----
+      #
+      # @example EnforcedStyle: braces (default)
+      #   # bad
+      #   [1, 2, one: 1, two: 2]
+      #
+      #   # good
+      #   [1, 2, { one: 1, two: 2 }]
+      #
+      #   # bad
+      #   [one: 1, two: 2]
+      #
+      #   # good
+      #   [{ one: 1, two: 2 }]
+      #
+      # @example EnforcedStyle: no_braces
+      #   # bad
+      #   [1, 2, { one: 1, two: 2 }]
+      #
+      #   # good
+      #   [1, 2, one: 1, two: 2]
+      #
+      #   # bad
+      #   [{ one: 1, two: 2 }]
+      #
+      #   # good
+      #   [one: 1, two: 2]
+      class HashAsLastArrayItem < Base
+        include RangeHelp
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        def on_hash(node)
+          return if node.children.first&.kwsplat_type?
+          return unless (array = containing_array(node))
+          return unless expected_braced_last_array_item?(array, node) && explicit_array?(array)
+
+          if braces_style?
+            check_braces(node)
+          else
+            check_no_braces(node)
+          end
+        end
+
+        private
+
+        def containing_array(hash_node)
+          parent = hash_node.parent
+          parent if parent&.array_type?
+        end
+
+        def expected_braced_last_array_item?(array, node)
+          return false if array.each_value.all? do |node|
+            node.hash_type? && (braces_style? ? node.braces? : !node.braces?)
+          end
+
+          !array.values[-2]&.hash_type? && array.values.last.equal?(node)
+        end
+
+        def explicit_array?(array)
+          # an implicit array cannot have an "unbraced" hash
+          array.square_brackets?
+        end
+
+        def check_braces(node)
+          return if node.braces?
+
+          add_offense(node, message: 'Wrap hash in `{` and `}`.') do |corrector|
+            if node.single_line? || same_line?(node, node.parent)
+              corrector.wrap(node, '{', '}')
+            else
+              indent = indent(node)
+              corrector.wrap(node, "{\n#{indent}", "\n#{indent}}")
+            end
+          end
+        end
+
+        def check_no_braces(node)
+          return unless node.braces?
+          return if node.children.empty? # Empty hash cannot be "unbraced"
+
+          add_offense(node, message: 'Omit the braces around the hash.') do |corrector|
+            remove_last_element_trailing_comma(corrector, node.parent)
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        def braces_style?
+          style == :braces
+        end
+
+        def remove_last_element_trailing_comma(corrector, node)
+          range = range_with_surrounding_space(
+            node.children.last.source_range,
+            side: :right
+          ).end.resize(1)
+
+          corrector.remove(range) if range.source == ','
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/style/hash_conversion.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks the usage of pre-2.1 `Hash[args]` method of converting enumerables and
+      # sequences of values to hashes.
+      #
+      # Correction code from splat argument (`Hash[*ary]`) is not simply determined. For example,
+      # `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated.
+      # So, `AllowSplatArgument` option is true by default to allow splat argument for simple code.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because `ArgumentError` occurs
+      #   if the number of elements is odd:
+      #
+      #   [source,ruby]
+      #   ----
+      #   Hash[[[1, 2], [3]]] #=> {1=>2, 3=>nil}
+      #   [[1, 2], [5]].to_h  #=> wrong array length at 1 (expected 2, was 1) (ArgumentError)
+      #   ----
+      #
+      # @example
+      #   # bad
+      #   Hash[ary]
+      #
+      #   # good
+      #   ary.to_h
+      #
+      #   # bad
+      #   Hash[key1, value1, key2, value2]
+      #
+      #   # good
+      #   {key1 => value1, key2 => value2}
+      #
+      # @example AllowSplatArgument: true (default)
+      #   # good
+      #   Hash[*ary]
+      #
+      # @example AllowSplatArgument: false
+      #   # bad
+      #   Hash[*ary]
+      #
+      class HashConversion < Base
+        extend AutoCorrector
+
+        MSG_TO_H = 'Prefer `ary.to_h` to `Hash[ary]`.'
+        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to `Hash[arg1, arg2, ...]`.'
+        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to `Hash[key: value, ...]`.'
+        MSG_SPLAT = 'Prefer `array_of_pairs.to_h` to `Hash[*array]`.'
+        RESTRICT_ON_SEND = %i[[]].freeze
+
+        # @!method hash_from_array?(node)
+        def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
+
+        def on_send(node)
+          return if part_of_ignored_node?(node) || !hash_from_array?(node)
+
+          # There are several cases:
+          # If there is one argument:
+          #   Hash[ary] => ary.to_h
+          #   Hash[*ary] => don't suggest corrections
+          # If there is 0 or 2+ arguments:
+          #   Hash[a1, a2, a3, a4] => {a1 => a2, a3 => a4}
+          #   ...but don't suggest correction if there is odd number of them (it is a bug)
+          node.arguments.one? ? single_argument(node) : multi_argument(node)
+          ignore_node(node)
+        end
+
+        private
+
+        def single_argument(node)
+          first_argument = node.first_argument
+          if first_argument.hash_type?
+            register_offense_for_hash(node, first_argument)
+          elsif first_argument.type?(:splat, :forwarded_restarg)
+            add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
+          elsif use_zip_method_without_argument?(first_argument)
+            register_offense_for_zip_method(node, first_argument)
+          else
+            add_offense(node, message: MSG_TO_H) do |corrector|
+              replacement = first_argument.source
+              replacement = "(#{replacement})" if requires_parens?(first_argument)
+              corrector.replace(node, "#{replacement}.to_h")
+            end
+          end
+        end
+
+        def use_zip_method_without_argument?(first_argument)
+          return false unless first_argument&.send_type?
+
+          first_argument.method?(:zip) && first_argument.arguments.empty?
+        end
+
+        def register_offense_for_hash(node, hash_argument)
+          add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
+            corrector.replace(node, "{#{hash_argument.source}}")
+
+            parent = node.parent
+            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+          end
+        end
+
+        def register_offense_for_zip_method(node, zip_method)
+          add_offense(node, message: MSG_TO_H) do |corrector|
+            if zip_method.parenthesized?
+              corrector.insert_before(zip_method.loc.end, '[]')
+            else
+              corrector.insert_after(zip_method, '([])')
+            end
+          end
+        end
+
+        def requires_parens?(node)
+          if node.call_type?
+            return false if node.method?(:[])
+            return true if node.arguments.any? && !node.parenthesized?
+          end
+
+          node.operator_keyword?
+        end
+
+        def multi_argument(node)
+          if node.arguments.count.odd?
+            add_offense(node, message: MSG_LITERAL_MULTI_ARG)
+          else
+            add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
+              corrector.replace(node, args_to_hash(node.arguments))
+
+              parent = node.parent
+              if parent&.send_type? && !parent.method?(:to_h) && !parent.parenthesized?
+                add_parentheses(parent, corrector)
+              end
+            end
+          end
+        end
+
+        def args_to_hash(args)
+          content = args.each_slice(2)
+                        .map { |arg1, arg2| "#{arg1.source} => #{arg2.source}" }
+                        .join(', ')
+          "{#{content}}"
+        end
+
+        def allowed_splat_argument?
+          cop_config.fetch('AllowSplatArgument', true)
+        end
+      end
+    end
+  end
+end