katalyst-govuk-formbuilder 1.9.2 → 1.9.4

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.64.1/lib/rubocop/cop/layout/space_before_block_braces.rb

@@ -1,163 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks that block braces have or don't have a space before the opening
-      # brace depending on configuration.
-      #
-      # @example EnforcedStyle: space (default)
-      #   # bad
-      #   foo.map{ |a|
-      #     a.bar.to_s
-      #   }
-      #
-      #   # good
-      #   foo.map { |a|
-      #     a.bar.to_s
-      #   }
-      #
-      # @example EnforcedStyle: no_space
-      #   # bad
-      #   foo.map { |a|
-      #     a.bar.to_s
-      #   }
-      #
-      #   # good
-      #   foo.map{ |a|
-      #     a.bar.to_s
-      #   }
-      #
-      # @example EnforcedStyleForEmptyBraces: space (default)
-      #   # bad
-      #   7.times{}
-      #
-      #   # good
-      #   7.times {}
-      #
-      # @example EnforcedStyleForEmptyBraces: no_space
-      #   # bad
-      #   7.times {}
-      #
-      #   # good
-      #   7.times{}
-      class SpaceBeforeBlockBraces < Base
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-        extend AutoCorrector
-
-        MISSING_MSG = 'Space missing to the left of {.'
-        DETECTED_MSG = 'Space detected to the left of {.'
-
-        def self.autocorrect_incompatible_with
-          [Style::SymbolProc]
-        end
-
-        def on_block(node)
-          return if node.keywords?
-
-          # Do not register an offense for multi-line braces when specifying
-          # `EnforcedStyle: no_space`. It will conflict with autocorrection
-          # by `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` cop.
-          # That means preventing autocorrection to incorrect autocorrected
-          # code.
-          # See: https://github.com/rubocop/rubocop/issues/7534
-          return if conflict_with_block_delimiters?(node)
-
-          left_brace = node.loc.begin
-          space_plus_brace = range_with_surrounding_space(left_brace)
-          used_style =
-            space_plus_brace.source.start_with?('{') ? :no_space : :space
-
-          if empty_braces?(node.loc)
-            check_empty(left_brace, space_plus_brace, used_style)
-          else
-            check_non_empty(left_brace, space_plus_brace, used_style)
-          end
-        end
-
-        alias on_numblock on_block
-
-        private
-
-        def check_empty(left_brace, space_plus_brace, used_style)
-          if style_for_empty_braces == used_style
-            handle_different_styles_for_empty_braces(used_style)
-            return
-          elsif !config_to_allow_offenses.key?('Enabled')
-            config_to_allow_offenses['EnforcedStyleForEmptyBraces'] = used_style.to_s
-          end
-
-          if style_for_empty_braces == :space
-            range = left_brace
-            msg = MISSING_MSG
-          else
-            range = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
-            msg = DETECTED_MSG
-          end
-          add_offense(range, message: msg) { |corrector| autocorrect(corrector, range) }
-        end
-
-        def handle_different_styles_for_empty_braces(used_style)
-          if config_to_allow_offenses['EnforcedStyleForEmptyBraces'] &&
-             config_to_allow_offenses['EnforcedStyleForEmptyBraces'].to_sym != used_style
-            config_to_allow_offenses.clear
-            config_to_allow_offenses['Enabled'] = false
-          end
-        end
-
-        def check_non_empty(left_brace, space_plus_brace, used_style)
-          case used_style
-          when style  then correct_style_detected
-          when :space then space_detected(left_brace, space_plus_brace)
-          else             space_missing(left_brace)
-          end
-        end
-
-        def space_missing(left_brace)
-          add_offense(left_brace, message: MISSING_MSG) do |corrector|
-            autocorrect(corrector, left_brace)
-            opposite_style_detected
-          end
-        end
-
-        def space_detected(left_brace, space_plus_brace)
-          space = range_between(space_plus_brace.begin_pos, left_brace.begin_pos)
-
-          add_offense(space, message: DETECTED_MSG) do |corrector|
-            autocorrect(corrector, space)
-            opposite_style_detected
-          end
-        end
-
-        def autocorrect(corrector, range)
-          case range.source
-          when /\s/ then corrector.remove(range)
-          else           corrector.insert_before(range, ' ')
-          end
-        end
-
-        def style_for_empty_braces
-          case cop_config['EnforcedStyleForEmptyBraces']
-          when 'space'    then :space
-          when 'no_space' then :no_space
-          when nil then style
-          else raise 'Unknown EnforcedStyleForEmptyBraces selected!'
-          end
-        end
-
-        def conflict_with_block_delimiters?(node)
-          block_delimiters_style == 'line_count_based' && style == :no_space && node.multiline?
-        end
-
-        def block_delimiters_style
-          config.for_cop('Style/BlockDelimiters')['EnforcedStyle']
-        end
-
-        def empty_braces?(loc)
-          loc.begin.end_pos == loc.end.begin_pos
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.64.1/lib/rubocop/cop/layout/space_before_brackets.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for space between the name of a receiver and a left
-      # brackets.
-      #
-      # @example
-      #
-      #   # bad
-      #   collection [index_or_key]
-      #
-      #   # good
-      #   collection[index_or_key]
-      #
-      class SpaceBeforeBrackets < Base
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Remove the space before the opening brackets.'
-        RESTRICT_ON_SEND = %i[[] []=].freeze
-
-        def on_send(node)
-          return unless (first_argument = node.first_argument)
-
-          begin_pos = first_argument.source_range.begin_pos
-          return unless (range = offense_range(node, begin_pos))
-
-          register_offense(range)
-        end
-
-        private
-
-        def offense_range(node, begin_pos)
-          if reference_variable_with_brackets?(node)
-            receiver_end_pos = node.receiver.source_range.end_pos
-            selector_begin_pos = node.loc.selector.begin_pos
-            return if receiver_end_pos >= selector_begin_pos
-            return if dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
-
-            range_between(receiver_end_pos, selector_begin_pos)
-          elsif node.method?(:[]=)
-            offense_range_for_assignment(node, begin_pos)
-          end
-        end
-
-        def dot_before_brackets?(node, receiver_end_pos, selector_begin_pos)
-          return false unless node.loc.respond_to?(:dot) && (dot = node.loc.dot)
-
-          dot.begin_pos == receiver_end_pos && dot.end_pos == selector_begin_pos
-        end
-
-        def offense_range_for_assignment(node, begin_pos)
-          end_pos = node.receiver.source_range.end_pos
-
-          return if begin_pos - end_pos == 1 ||
-                    (range = range_between(end_pos, begin_pos - 1)).source.start_with?('[')
-
-          range
-        end
-
-        def register_offense(range)
-          add_offense(range) { |corrector| corrector.remove(range) }
-        end
-
-        def reference_variable_with_brackets?(node)
-          node.receiver&.variable? && node.method?(:[]) && node.arguments.size == 1
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.64.1/lib/rubocop/cop/layout/space_before_comma.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for comma (,) preceded by space.
-      #
-      # @example
-      #   # bad
-      #   [1 , 2 , 3]
-      #   a(1 , 2)
-      #   each { |a , b| }
-      #
-      #   # good
-      #   [1, 2, 3]
-      #   a(1, 2)
-      #   each { |a, b| }
-      #
-      class SpaceBeforeComma < Base
-        include SpaceBeforePunctuation
-        extend AutoCorrector
-
-        def kind(token)
-          'comma' if token.comma?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.64.1/lib/rubocop/cop/layout/space_before_comment.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for missing space between a token and a comment on the
-      # same line.
-      #
-      # @example
-      #   # bad
-      #   1 + 1# this operation does ...
-      #
-      #   # good
-      #   1 + 1 # this operation does ...
-      class SpaceBeforeComment < Base
-        extend AutoCorrector
-
-        MSG = 'Put a space before an end-of-line comment.'
-
-        def on_new_investigation
-          processed_source.sorted_tokens.each_cons(2) do |token1, token2|
-            next unless token2.comment?
-            next unless same_line?(token1, token2)
-            next unless token1.pos.end == token2.pos.begin
-
-            range = token2.pos
-
-            add_offense(range) { |corrector| corrector.insert_before(range, ' ') }
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.64.1/lib/rubocop/cop/layout/space_before_first_arg.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks that exactly one space is used between a method name and the
-      # first argument for method calls without parentheses.
-      #
-      # Alternatively, extra spaces can be added to align the argument with
-      # something on a preceding or following line, if the AllowForAlignment
-      # config parameter is true.
-      #
-      # @example
-      #   # bad
-      #   something  x
-      #   something   y, z
-      #   something'hello'
-      #
-      #   # good
-      #   something x
-      #   something y, z
-      #   something 'hello'
-      #
-      class SpaceBeforeFirstArg < Base
-        include PrecedingFollowingAlignment
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG = 'Put one space between the method name and the first argument.'
-
-        def self.autocorrect_incompatible_with
-          [Style::MethodCallWithArgsParentheses]
-        end
-
-        def on_send(node)
-          return unless regular_method_call_with_arguments?(node)
-          return if node.parenthesized?
-
-          first_arg = node.first_argument.source_range
-          first_arg_with_space = range_with_surrounding_space(first_arg, side: :left)
-          space = range_between(first_arg_with_space.begin_pos, first_arg.begin_pos)
-          return if space.length == 1
-          return unless expect_params_after_method_name?(node)
-
-          add_offense(space) { |corrector| corrector.replace(space, ' ') }
-        end
-        alias on_csend on_send
-
-        private
-
-        def regular_method_call_with_arguments?(node)
-          node.arguments? && !node.operator_method? && !node.setter_method?
-        end
-
-        def expect_params_after_method_name?(node)
-          return true if no_space_between_method_name_and_first_argument?(node)
-
-          first_arg = node.first_argument
-
-          same_line?(first_arg, node) &&
-            !(allow_for_alignment? && aligned_with_something?(first_arg.source_range))
-        end
-
-        def no_space_between_method_name_and_first_argument?(node)
-          end_pos_of_method_name = node.loc.selector.end_pos
-          begin_pos_of_argument = node.first_argument.source_range.begin_pos
-
-          end_pos_of_method_name == begin_pos_of_argument
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.64.1/lib/rubocop/cop/layout/space_before_semicolon.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for semicolon (;) preceded by space.
-      #
-      # @example
-      #   # bad
-      #   x = 1 ; y = 2
-      #
-      #   # good
-      #   x = 1; y = 2
-      class SpaceBeforeSemicolon < Base
-        include SpaceBeforePunctuation
-        extend AutoCorrector
-
-        def kind(token)
-          'semicolon' if token.semicolon?
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.64.1/lib/rubocop/cop/layout/space_in_lambda_literal.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for spaces between `->` and opening parameter
-      # parenthesis (`(`) in lambda literals.
-      #
-      # @example EnforcedStyle: require_no_space (default)
-      #     # bad
-      #     a = -> (x, y) { x + y }
-      #
-      #     # good
-      #     a = ->(x, y) { x + y }
-      #
-      # @example EnforcedStyle: require_space
-      #     # bad
-      #     a = ->(x, y) { x + y }
-      #
-      #     # good
-      #     a = -> (x, y) { x + y }
-      class SpaceInLambdaLiteral < Base
-        include ConfigurableEnforcedStyle
-        include RangeHelp
-        extend AutoCorrector
-
-        MSG_REQUIRE_SPACE = 'Use a space between `->` and `(` in lambda literals.'
-        MSG_REQUIRE_NO_SPACE = 'Do not use spaces between `->` and `(` in lambda literals.'
-
-        def on_send(node)
-          return unless arrow_lambda_with_args?(node)
-
-          if style == :require_space && !space_after_arrow?(node)
-            lambda_node = range_of_offense(node)
-
-            add_offense(lambda_node, message: MSG_REQUIRE_SPACE) do |corrector|
-              corrector.insert_before(lambda_arguments(node), ' ')
-            end
-          elsif style == :require_no_space && space_after_arrow?(node)
-            space = space_after_arrow(node)
-
-            add_offense(space, message: MSG_REQUIRE_NO_SPACE) do |corrector|
-              corrector.remove(space)
-            end
-          end
-        end
-
-        private
-
-        def arrow_lambda_with_args?(node)
-          node.lambda_literal? && node.parent.arguments?
-        end
-
-        def space_after_arrow?(lambda_node)
-          !space_after_arrow(lambda_node).empty?
-        end
-
-        def space_after_arrow(lambda_node)
-          arrow = lambda_node.parent.children[0].source_range
-          parentheses = lambda_node.parent.children[1].source_range
-
-          arrow.end.join(parentheses.begin)
-        end
-
-        def range_of_offense(node)
-          range_between(
-            node.parent.source_range.begin_pos,
-            node.parent.arguments.source_range.end_pos
-          )
-        end
-
-        def lambda_arguments(node)
-          node.parent.children[1]
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/3.3.0/gems/rubocop-1.64.1/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks that brackets used for array literals have or don't have
-      # surrounding space depending on configuration.
-      #
-      # @example EnforcedStyle: no_space (default)
-      #   # The `no_space` style enforces that array literals have
-      #   # no surrounding space.
-      #
-      #   # bad
-      #   array = [ a, b, c, d ]
-      #
-      #   # good
-      #   array = [a, b, c, d]
-      #
-      # @example EnforcedStyle: space
-      #   # The `space` style enforces that array literals have
-      #   # surrounding space.
-      #
-      #   # bad
-      #   array = [a, b, c, d]
-      #
-      #   # good
-      #   array = [ a, b, c, d ]
-      #
-      # @example EnforcedStyle: compact
-      #   # The `compact` style normally requires a space inside
-      #   # array brackets, with the exception that successive left
-      #   # or right brackets are collapsed together in nested arrays.
-      #
-      #   # bad
-      #   array = [ a, [ b, c ] ]
-      #   array = [
-      #     [ a ],
-      #     [ b, c ]
-      #   ]
-      #
-      #   # good
-      #   array = [ a, [ b, c ]]
-      #   array = [[ a ],
-      #     [ b, c ]]
-      #
-      # @example EnforcedStyleForEmptyBrackets: no_space (default)
-      #   # The `no_space` EnforcedStyleForEmptyBrackets style enforces that
-      #   # empty array brackets do not contain spaces.
-      #
-      #   # bad
-      #   foo = [ ]
-      #   bar = [     ]
-      #
-      #   # good
-      #   foo = []
-      #   bar = []
-      #
-      # @example EnforcedStyleForEmptyBrackets: space
-      #   # The `space` EnforcedStyleForEmptyBrackets style enforces that
-      #   # empty array brackets contain exactly one space.
-      #
-      #   # bad
-      #   foo = []
-      #   bar = [    ]
-      #
-      #   # good
-      #   foo = [ ]
-      #   bar = [ ]
-      #
-      class SpaceInsideArrayLiteralBrackets < Base
-        include SurroundingSpace
-        include ConfigurableEnforcedStyle
-        extend AutoCorrector
-
-        MSG = '%<command>s space inside array brackets.'
-        EMPTY_MSG = '%<command>s space inside empty array brackets.'
-
-        def on_array(node)
-          return unless node.square_brackets?
-
-          tokens, left, right = array_brackets(node)
-
-          if empty_brackets?(left, right, tokens: tokens)
-            return empty_offenses(node, left, right, EMPTY_MSG)
-          end
-
-          start_ok = next_to_newline?(node, left)
-          end_ok = node.single_line? ? false : end_has_own_line?(right)
-
-          issue_offenses(node, left, right, start_ok, end_ok)
-        end
-
-        private
-
-        def autocorrect(corrector, node)
-          tokens, left, right = array_brackets(node)
-
-          if empty_brackets?(left, right, tokens: tokens)
-            SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
-          elsif style == :no_space
-            SpaceCorrector.remove_space(processed_source, corrector, left, right)
-          elsif style == :space
-            SpaceCorrector.add_space(processed_source, corrector, left, right)
-          else
-            compact_corrections(corrector, node, left, right)
-          end
-        end
-
-        def array_brackets(node)
-          tokens = processed_source.tokens_within(node)
-
-          left = tokens.find(&:left_array_bracket?)
-          right = tokens.reverse_each.find(&:right_bracket?)
-
-          [tokens, left, right]
-        end
-
-        def empty_config
-          cop_config['EnforcedStyleForEmptyBrackets']
-        end
-
-        def next_to_newline?(node, token)
-          processed_source.tokens_within(node)[index_for(node, token) + 1].line != token.line
-        end
-
-        def end_has_own_line?(token)
-          line, col = line_and_column_for(token)
-          return true if col == -1
-
-          !/\S/.match?(processed_source.lines[line][0..col])
-        end
-
-        def index_for(node, token)
-          processed_source.tokens_within(node).index(token)
-        end
-
-        def line_and_column_for(token)
-          [token.line - 1, token.column - 1]
-        end
-
-        def issue_offenses(node, left, right, start_ok, end_ok)
-          case style
-          when :no_space
-            start_ok = next_to_comment?(node, left)
-            no_space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
-          when :space
-            space_offenses(node, left, right, MSG, start_ok: start_ok, end_ok: end_ok)
-          else
-            compact_offenses(node, left, right, start_ok, end_ok)
-          end
-        end
-
-        def next_to_comment?(node, token)
-          processed_source.tokens_within(node)[index_for(node, token) + 1].comment?
-        end
-
-        def compact_offenses(node, left, right, start_ok, end_ok)
-          if qualifies_for_compact?(node, left, side: :left)
-            compact_offense(node, left, side: :left)
-          elsif !multi_dimensional_array?(node, left, side: :left)
-            space_offenses(node, left, nil, MSG, start_ok: start_ok, end_ok: true)
-          end
-          if qualifies_for_compact?(node, right)
-            compact_offense(node, right)
-          elsif !multi_dimensional_array?(node, right)
-            space_offenses(node, nil, right, MSG, start_ok: true, end_ok: end_ok)
-          end
-        end
-
-        def qualifies_for_compact?(node, token, side: :right)
-          if side == :right
-            multi_dimensional_array?(node, token) && token.space_before?
-          else
-            multi_dimensional_array?(node, token, side: :left) && token.space_after?
-          end
-        end
-
-        def multi_dimensional_array?(node, token, side: :right)
-          offset = side == :right ? -1 : +1
-          i = index_for(node, token) + offset
-          i += offset while processed_source.tokens_within(node)[i].new_line?
-          if side == :right
-            processed_source.tokens_within(node)[i].right_bracket?
-          else
-            processed_source.tokens_within(node)[i].left_array_bracket?
-          end
-        end
-
-        def next_to_bracket?(token, side: :right)
-          line_index, col = line_and_column_for(token)
-          line = processed_source.lines[line_index]
-          side == :right ? line[col] == ']' : line[col + 2] == '['
-        end
-
-        def compact_offense(node, token, side: :right)
-          if side == :right
-            space_offense(node, token, :left, MSG, NO_SPACE_COMMAND)
-          else
-            space_offense(node, token, :right, MSG, NO_SPACE_COMMAND)
-          end
-        end
-
-        def compact_corrections(corrector, node, left, right)
-          if multi_dimensional_array?(node, left, side: :left)
-            compact(corrector, left, :right)
-          elsif !left.space_after?
-            corrector.insert_after(left.pos, ' ')
-          end
-
-          if multi_dimensional_array?(node, right)
-            compact(corrector, right, :left)
-          elsif !right.space_before?
-            corrector.insert_before(right.pos, ' ')
-          end
-        end
-
-        def compact(corrector, bracket, side)
-          range = side_space_range(range: bracket.pos, side: side, include_newlines: true)
-          corrector.remove(range)
-        end
-      end
-    end
-  end
-end