cocRb 0.1.0 → 1.1.5

data/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/layout/space_inside_array_percent_literal.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for unnecessary additional spaces inside array percent literals
-      # (i.e. %i/%w).
-      #
-      # @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/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -1,243 +0,0 @@
-# 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 on_block(node)
-          return if node.keywords?
-
-          # Do not register an offense for multi-line empty braces. That means
-          # preventing auto-correction to single-line empty braces. It will
-          # conflict with auto-correction by `Layout/SpaceInsideBlockBraces` cop
-          # if auto-corrected 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
-
-        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 # Can be ( | or nil.
-
-          check_left_brace(inner, node.loc.begin, args_delimiter)
-          check_right_brace(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(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
-            return if multiline_block?(left_brace, right_brace) &&
-                      aligned_braces?(left_brace, right_brace)
-
-            space_inside_right_brace(right_brace)
-          end
-        end
-
-        def multiline_block?(left_brace, right_brace)
-          left_brace.first_line != right_brace.first_line
-        end
-
-        def aligned_braces?(left_brace, right_brace)
-          left_brace.first_line == right_brace.last_column
-        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(range: 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(right_brace)
-          brace_with_space = range_with_surrounding_space(range: right_brace, side: :left)
-          space(brace_with_space.begin_pos, brace_with_space.end_pos - 1,
-                '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')
-          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/.bundle/ruby/3.0.0/gems/rubocop-1.14.0/lib/rubocop/cop/layout/space_inside_hash_literal_braces.rb

@@ -1,181 +0,0 @@
-# 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.
-      #
-      # @example EnforcedStyle: space (default)
-      #   # The `space` style enforces that hash literals have
-      #   # surrounding space.
-      #
-      #   # bad
-      #   h = {a: 1, b: 2}
-      #
-      #   # good
-      #   h = { a: 1, b: 2 }
-      #
-      # @example EnforcedStyle: no_space
-      #   # The `no_space` style enforces that hash literals have
-      #   # no surrounding space.
-      #
-      #   # bad
-      #   h = { a: 1, b: 2 }
-      #
-      #   # good
-      #   h = {a: 1, b: 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 = {    }
-      #
-      #   # good
-      #   foo = {}
-      #   bar = {}
-      #
-      # @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
-        end
-
-        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
-            cop_config['EnforcedStyleForEmptyBraces'] != 'no_space'
-          else
-            style != :no_space
-          end
-        end
-
-        def incorrect_style_detected(token1, token2,
-                                     expect_space, is_empty_braces)
-          brace = (token1.text == '{' ? 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
-      end
-    end
-  end
-end