super-pro-sys 0.0.1

data/rubocop-1.88.1/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for unnecessary additional spaces inside array percent literals
+      # (i.e. %i/%w).
+      #
+      # Note that blank percent literals (e.g. `%i( )`) are checked by
+      # `Layout/SpaceInsidePercentLiteralDelimiters`.
+      #
+      # @example
+      #
+      #   # bad
+      #   %w(foo  bar  baz)
+      #   # good
+      #   %i(foo bar baz)
+      class SpaceInsideArrayPercentLiteral < Base
+        include MatchRange
+        include PercentLiteral
+        extend AutoCorrector
+
+        MSG = 'Use only a single space inside array percent literal.'
+        MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = /(?:[\S&&[^\\]](?:\\ )*)( {2,})(?=\S)/.freeze
+
+        def on_array(node)
+          process(node, '%i', '%I', '%w', '%W')
+        end
+
+        def on_percent_literal(node)
+          each_unnecessary_space_match(node) do |range|
+            add_offense(range) do |corrector|
+              corrector.replace(range, ' ')
+            end
+          end
+        end
+
+        private
+
+        def each_unnecessary_space_match(node, &blk)
+          each_match_range(contents_range(node), MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX, &blk)
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that block braces have or don't have surrounding space inside
+      # them on configuration. For blocks taking parameters, it checks that the
+      # left brace has or doesn't have trailing space depending on
+      # configuration.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # The `space` style enforces that block braces have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   some_array.each {puts e}
+      #
+      #   # good
+      #   some_array.each { puts e }
+      #
+      # @example EnforcedStyle: no_space
+      #   # The `no_space` style enforces that block braces don't
+      #   # have surrounding space.
+      #
+      #   # bad
+      #   some_array.each { puts e }
+      #
+      #   # good
+      #   some_array.each {puts e}
+      #
+      #
+      # @example EnforcedStyleForEmptyBraces: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBraces style enforces that
+      #   # block braces don't have a space in between when empty.
+      #
+      #   # bad
+      #   some_array.each {   }
+      #   some_array.each {  }
+      #   some_array.each { }
+      #
+      #   # good
+      #   some_array.each {}
+      #
+      # @example EnforcedStyleForEmptyBraces: space
+      #   # The `space` EnforcedStyleForEmptyBraces style enforces that
+      #   # block braces have at least a space in between when empty.
+      #
+      #   # bad
+      #   some_array.each {}
+      #
+      #   # good
+      #   some_array.each { }
+      #   some_array.each {  }
+      #   some_array.each {   }
+      #
+      #
+      # @example SpaceBeforeBlockParameters: true (default)
+      #   # The SpaceBeforeBlockParameters style set to `true` enforces that
+      #   # there is a space between `{` and `|`. Overrides `EnforcedStyle`
+      #   # if there is a conflict.
+      #
+      #   # bad
+      #   [1, 2, 3].each {|n| n * 2 }
+      #
+      #   # good
+      #   [1, 2, 3].each { |n| n * 2 }
+      #
+      # @example SpaceBeforeBlockParameters: false
+      #   # The SpaceBeforeBlockParameters style set to `false` enforces that
+      #   # there is no space between `{` and `|`. Overrides `EnforcedStyle`
+      #   # if there is a conflict.
+      #
+      #   # bad
+      #   [1, 2, 3].each { |n| n * 2 }
+      #
+      #   # good
+      #   [1, 2, 3].each {|n| n * 2 }
+      #
+      class SpaceInsideBlockBraces < Base
+        include ConfigurableEnforcedStyle
+        include SurroundingSpace
+        include RangeHelp
+        extend AutoCorrector
+
+        def self.autocorrect_incompatible_with
+          [Style::BlockDelimiters]
+        end
+
+        def on_block(node)
+          return if node.keywords?
+
+          # Do not register an offense for multi-line empty braces. That means
+          # preventing autocorrection to single-line empty braces. It will
+          # conflict with autocorrection by `Layout/SpaceInsideBlockBraces` cop
+          # if autocorrected to a single-line empty braces.
+          # See: https://github.com/rubocop/rubocop/issues/7363
+          return if node.body.nil? && node.multiline?
+
+          left_brace = node.loc.begin
+          right_brace = node.loc.end
+
+          check_inside(node, left_brace, right_brace)
+        end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        private
+
+        def check_inside(node, left_brace, right_brace)
+          if left_brace.end_pos == right_brace.begin_pos
+            adjacent_braces(left_brace, right_brace)
+          else
+            range = range_between(left_brace.end_pos, right_brace.begin_pos)
+            inner = range.source
+
+            if /\S/.match?(inner)
+              braces_with_contents_inside(node, inner)
+            elsif style_for_empty_braces == :no_space
+              offense(range.begin_pos, range.end_pos,
+                      'Space inside empty braces detected.',
+                      'EnforcedStyleForEmptyBraces')
+            end
+          end
+        end
+
+        def adjacent_braces(left_brace, right_brace)
+          return if style_for_empty_braces != :space
+
+          offense(left_brace.begin_pos, right_brace.end_pos,
+                  'Space missing inside empty braces.',
+                  'EnforcedStyleForEmptyBraces')
+        end
+
+        def braces_with_contents_inside(node, inner)
+          args_delimiter = node.arguments.loc.begin if node.block_type? # Can be ( | or nil.
+
+          check_left_brace(inner, node.loc.begin, args_delimiter)
+          check_right_brace(node, inner, node.loc.begin, node.loc.end, node.single_line?)
+        end
+
+        def check_left_brace(inner, left_brace, args_delimiter)
+          if /\A\S/.match?(inner)
+            no_space_inside_left_brace(left_brace, args_delimiter)
+          else
+            space_inside_left_brace(left_brace, args_delimiter)
+          end
+        end
+
+        def check_right_brace(node, inner, left_brace, right_brace, single_line)
+          if single_line && /\S$/.match?(inner)
+            no_space(right_brace.begin_pos, right_brace.end_pos, 'Space missing inside }.')
+          else
+            column = node.source_range.column
+            return if multiline_block?(left_brace, right_brace) &&
+                      aligned_braces?(inner, right_brace, column)
+
+            space_inside_right_brace(inner, right_brace, column)
+          end
+        end
+
+        def multiline_block?(left_brace, right_brace)
+          left_brace.first_line != right_brace.first_line
+        end
+
+        def aligned_braces?(inner, right_brace, column)
+          column == right_brace.column || column == inner_last_space_count(inner)
+        end
+
+        def inner_last_space_count(inner)
+          inner.split("\n").last.count(' ')
+        end
+
+        def no_space_inside_left_brace(left_brace, args_delimiter)
+          if pipe?(args_delimiter)
+            if left_brace.end_pos == args_delimiter.begin_pos &&
+               cop_config['SpaceBeforeBlockParameters']
+              offense(left_brace.begin_pos, args_delimiter.end_pos,
+                      'Space between { and | missing.')
+            else
+              correct_style_detected
+            end
+          else
+            # We indicate the position after the left brace. Otherwise it's
+            # difficult to distinguish between space missing to the left and to
+            # the right of the brace in autocorrect.
+            no_space(left_brace.end_pos, left_brace.end_pos + 1, 'Space missing inside {.')
+          end
+        end
+
+        def space_inside_left_brace(left_brace, args_delimiter)
+          if pipe?(args_delimiter)
+            if cop_config['SpaceBeforeBlockParameters']
+              correct_style_detected
+            else
+              offense(left_brace.end_pos, args_delimiter.begin_pos,
+                      'Space between { and | detected.')
+            end
+          else
+            brace_with_space = range_with_surrounding_space(left_brace, side: :right)
+            space(brace_with_space.begin_pos + 1, brace_with_space.end_pos,
+                  'Space inside { detected.')
+          end
+        end
+
+        def pipe?(args_delimiter)
+          args_delimiter&.is?('|')
+        end
+
+        def space_inside_right_brace(inner, right_brace, column)
+          brace_with_space = range_with_surrounding_space(right_brace, side: :left)
+          begin_pos = brace_with_space.begin_pos
+          end_pos = brace_with_space.end_pos - 1
+
+          if brace_with_space.source.match?(/\R/)
+            begin_pos = end_pos - (right_brace.column - column)
+          end
+
+          if inner.end_with?(']')
+            end_pos -= 1
+            begin_pos = end_pos - (inner_last_space_count(inner) - column)
+          end
+
+          space(begin_pos, end_pos, 'Space inside } detected.')
+        end
+
+        def no_space(begin_pos, end_pos, msg)
+          if style == :space
+            offense(begin_pos, end_pos, msg)
+          else
+            correct_style_detected
+          end
+        end
+
+        def space(begin_pos, end_pos, msg)
+          if style == :no_space
+            offense(begin_pos, end_pos, msg)
+          else
+            correct_style_detected
+          end
+        end
+
+        def offense(begin_pos, end_pos, msg, style_param = 'EnforcedStyle')
+          return if begin_pos > end_pos
+
+          range = range_between(begin_pos, end_pos)
+          add_offense(range, message: msg) do |corrector|
+            case range.source
+            when /\s/ then corrector.remove(range)
+            when '{}' then corrector.replace(range, '{ }')
+            when '{|' then corrector.replace(range, '{ |')
+            else           corrector.insert_before(range, ' ')
+            end
+            opposite_style_detected if style_param == 'EnforcedStyle'
+          end
+        end
+
+        def style_for_empty_braces
+          case cop_config['EnforcedStyleForEmptyBraces']
+          when 'space'    then :space
+          when 'no_space' then :no_space
+          else raise 'Unknown EnforcedStyleForEmptyBraces selected!'
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that braces used for hash literals have or don't have
+      # surrounding space depending on configuration.
+      #
+      # Hash pattern matching is handled in the same way.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # The `space` style enforces that hash literals have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   h = {a: 1, b: 2}
+      #   foo = {{ a: 1 } => { b: { c: 2 }}}
+      #
+      #   # good
+      #   h = { a: 1, b: 2 }
+      #   foo = { { a: 1 } => { b: { c: 2 } } }
+      #
+      # @example EnforcedStyle: no_space
+      #   # The `no_space` style enforces that hash literals have
+      #   # no surrounding space.
+      #
+      #   # bad
+      #   h = { a: 1, b: 2 }
+      #   foo = {{ a: 1 } => { b: { c: 2 }}}
+      #
+      #   # good
+      #   h = {a: 1, b: 2}
+      #   foo = {{a: 1} => {b: {c: 2}}}
+      #
+      # @example EnforcedStyle: compact
+      #   # The `compact` style normally requires a space inside
+      #   # hash braces, with the exception that successive left
+      #   # braces or right braces are collapsed together in nested hashes.
+      #
+      #   # bad
+      #   h = { a: { b: 2 } }
+      #   foo = { { a: 1 } => { b: { c: 2 } } }
+      #
+      #   # good
+      #   h = { a: { b: 2 }}
+      #   foo = {{ a: 1 } => { b: { c: 2 }}}
+      #
+      # @example EnforcedStyleForEmptyBraces: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBraces style enforces that
+      #   # empty hash braces do not contain spaces.
+      #
+      #   # bad
+      #   foo = { }
+      #   bar = {    }
+      #   baz = {
+      #   }
+      #
+      #   # good
+      #   foo = {}
+      #   bar = {}
+      #   baz = {}
+      #
+      # @example EnforcedStyleForEmptyBraces: space
+      #   # The `space` EnforcedStyleForEmptyBraces style enforces that
+      #   # empty hash braces contain space.
+      #
+      #   # bad
+      #   foo = {}
+      #
+      #   # good
+      #   foo = { }
+      #   foo = {    }
+      #   foo = {
+      #   }
+      #
+      class SpaceInsideHashLiteralBraces < Base
+        include SurroundingSpace
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Space inside %<problem>s.'
+
+        def on_hash(node)
+          tokens = processed_source.tokens_within(node)
+          return unless tokens.first.left_brace? && tokens.last.right_curly_brace?
+
+          check(tokens[0], tokens[1])
+          check(tokens[-2], tokens[-1]) if tokens.size > 2
+          check_whitespace_only_hash(node) if enforce_no_space_style_for_empty_braces?
+        end
+        alias on_hash_pattern on_hash
+
+        private
+
+        def check(token1, token2)
+          # No offense if line break inside.
+          return if token1.line < token2.line
+          return if token2.comment? # Also indicates there's a line break.
+
+          is_empty_braces = token1.left_brace? && token2.right_curly_brace?
+          expect_space    = expect_space?(token1, token2)
+
+          if offense?(token1, expect_space)
+            incorrect_style_detected(token1, token2, expect_space, is_empty_braces)
+          else
+            correct_style_detected
+          end
+        end
+
+        def expect_space?(token1, token2)
+          is_same_braces  = token1.type == token2.type
+          is_empty_braces = token1.left_brace? && token2.right_curly_brace?
+
+          if is_same_braces && style == :compact
+            false
+          elsif is_empty_braces
+            !enforce_no_space_style_for_empty_braces?
+          else
+            style != :no_space
+          end
+        end
+
+        def incorrect_style_detected(token1, token2,
+                                     expect_space, is_empty_braces)
+          brace = (token1.left_brace? ? token1 : token2).pos
+          range = expect_space ? brace : space_range(brace)
+          detected_style = expect_space ? 'no_space' : 'space'
+
+          add_offense(range, message: message(brace, is_empty_braces, expect_space)) do |corrector|
+            autocorrect(corrector, range)
+            ambiguous_or_unexpected_style_detected(detected_style, token1.text == token2.text)
+          end
+        end
+
+        def autocorrect(corrector, range)
+          case range.source
+          when /\s/ then corrector.remove(range)
+          when '{' then corrector.insert_after(range, ' ')
+          else corrector.insert_before(range, ' ')
+          end
+        end
+
+        def ambiguous_or_unexpected_style_detected(style, is_match)
+          if is_match
+            ambiguous_style_detected(style, :compact)
+          else
+            unexpected_style_detected(style)
+          end
+        end
+
+        def offense?(token1, expect_space)
+          has_space = token1.space_after?
+          expect_space ? !has_space : has_space
+        end
+
+        def message(brace, is_empty_braces, expect_space)
+          inside_what = if is_empty_braces
+                          'empty hash literal braces'
+                        else
+                          brace.source
+                        end
+          problem = expect_space ? 'missing' : 'detected'
+          format(MSG, problem: "#{inside_what} #{problem}")
+        end
+
+        def space_range(token_range)
+          if token_range.source == '{'
+            range_of_space_to_the_right(token_range)
+          else
+            range_of_space_to_the_left(token_range)
+          end
+        end
+
+        def range_of_space_to_the_right(range)
+          src = range.source_buffer.source
+          end_pos = range.end_pos
+          end_pos += 1 while /[ \t]/.match?(src[end_pos])
+
+          range_between(range.begin_pos + 1, end_pos)
+        end
+
+        def range_of_space_to_the_left(range)
+          src = range.source_buffer.source
+          begin_pos = range.begin_pos
+          begin_pos -= 1 while /[ \t]/.match?(src[begin_pos - 1])
+
+          range_between(begin_pos, range.end_pos - 1)
+        end
+
+        def check_whitespace_only_hash(node)
+          range = range_inside_hash(node)
+          return unless range.source.match?(/\A\s+\z/m)
+
+          add_offense(
+            range,
+            message: format(MSG, problem: 'empty hash literal braces detected')
+          ) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def range_inside_hash(node)
+          return node.source_range if node.location.begin.nil?
+
+          range_between(node.location.begin.end_pos, node.location.end.begin_pos)
+        end
+
+        def enforce_no_space_style_for_empty_braces?
+          cop_config['EnforcedStyleForEmptyBraces'] == 'no_space'
+        end
+      end
+    end
+  end
+end

data/rubocop-1.88.1/lib/rubocop/cop/layout/space_inside_parens.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for spaces inside ordinary round parentheses.
+      #
+      # @example EnforcedStyle: no_space (default)
+      #   # The `no_space` style enforces that parentheses do not have spaces.
+      #
+      #   # bad
+      #   f( 3)
+      #   g = (a + 3 )
+      #   f( )
+      #
+      #   # good
+      #   f(3)
+      #   g = (a + 3)
+      #   f()
+      #
+      # @example EnforcedStyle: space
+      #   # The `space` style enforces that parentheses have a space at the
+      #   # beginning and end.
+      #   # Note: Empty parentheses should not have spaces.
+      #
+      #   # bad
+      #   f(3)
+      #   g = (a + 3)
+      #   y( )
+      #
+      #   # good
+      #   f( 3 )
+      #   g = ( a + 3 )
+      #   y()
+      #
+      # @example EnforcedStyle: compact
+      #   # The `compact` style enforces that parentheses have a space at the
+      #   # beginning with the exception that successive parentheses are allowed.
+      #   # Note: Empty parentheses should not have spaces.
+      #
+      #   # bad
+      #   f(3)
+      #   g = (a + 3)
+      #   y( )
+      #   g( f( x ) )
+      #   g( f( x( 3 ) ), 5 )
+      #   g( ( ( 3 + 5 ) * f) ** x, 5 )
+      #
+      #   # good
+      #   f( 3 )
+      #   g = ( a + 3 )
+      #   y()
+      #   g( f( x ))
+      #   g( f( x( 3 )), 5 )
+      #   g((( 3 + 5 ) * f ) ** x, 5 )
+      #
+      class SpaceInsideParens < Base
+        include SurroundingSpace
+        include RangeHelp
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG       = 'Space inside parentheses detected.'
+        MSG_SPACE = 'No space inside parentheses detected.'
+
+        def on_new_investigation
+          tokens = processed_source.sorted_tokens
+
+          case style
+          when :space
+            process_with_space_style(tokens)
+          when :compact
+            process_with_compact_style(tokens)
+          else
+            correct_extraneous_space(tokens)
+          end
+        end
+
+        private
+
+        def process_with_space_style(tokens)
+          tokens.each_cons(2) do |token1, token2|
+            correct_extraneous_space_in_empty_parens(token1, token2)
+            correct_missing_space(token1, token2)
+          end
+        end
+
+        def process_with_compact_style(tokens)
+          tokens.each_cons(2) do |token1, token2|
+            correct_extraneous_space_in_empty_parens(token1, token2)
+            if !left_parens?(token1, token2) && !right_parens?(token1, token2)
+              correct_missing_space(token1, token2)
+            else
+              correct_extraneous_space_between_consecutive_parens(token1, token2)
+            end
+          end
+        end
+
+        def correct_extraneous_space(tokens)
+          tokens.each_cons(2) do |token1, token2|
+            next unless parens?(token1, token2)
+
+            # If the second token is a comment, that means that a line break
+            # follows, and that the rules for space inside don't apply.
+            next if token2.comment?
+            next unless same_line?(token1, token2) && token1.space_after?
+
+            range = range_between(token1.end_pos, token2.begin_pos)
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
+          end
+        end
+
+        def correct_extraneous_space_between_consecutive_parens(token1, token2)
+          return if range_between(token1.end_pos, token2.begin_pos).source != ' '
+
+          range = range_between(token1.end_pos, token2.begin_pos)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def correct_extraneous_space_in_empty_parens(token1, token2)
+          return unless token1.left_parens? && token2.right_parens?
+
+          return if range_between(token1.begin_pos, token2.end_pos).source == '()'
+
+          range = range_between(token1.end_pos, token2.begin_pos)
+          add_offense(range) do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        def correct_missing_space(token1, token2)
+          return if can_be_ignored?(token1, token2)
+
+          range = if token1.left_parens?
+                    range_between(token2.begin_pos, token2.begin_pos + 1)
+                  elsif token2.right_parens?
+                    range_between(token2.begin_pos, token2.end_pos)
+                  end
+
+          add_offense(range, message: MSG_SPACE) do |corrector|
+            corrector.insert_before(range, ' ')
+          end
+        end
+
+        def parens?(token1, token2)
+          token1.left_parens? || token2.right_parens?
+        end
+
+        def left_parens?(token1, token2)
+          token1.left_parens? && token2.left_parens?
+        end
+
+        def right_parens?(token1, token2)
+          token1.right_parens? && token2.right_parens?
+        end
+
+        def can_be_ignored?(token1, token2)
+          return true unless parens?(token1, token2)
+
+          # Ignore empty parentheses.
+          return true if range_between(token1.begin_pos, token2.end_pos).source == '()'
+
+          # If the second token is a comment, that means that a line break
+          # follows, and that the rules for space inside don't apply.
+          return true if token2.comment?
+
+          !same_line?(token1, token2) || token1.space_after?
+        end
+      end
+    end
+  end
+end