gettext_i18n_rails_js 2.3.0 → 2.3.1

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.0/lib/rubocop/cop/internal_affairs/location_exists.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      # When a node location may not exist, `Node#loc?` or `Node#loc_is?`
+      # can be used instead of calling `Node#respond_to?` before using
+      # the value.
+      #
+      # @example
+      #   # bad
+      #   node.loc.respond_to?(:begin)
+      #
+      #   # good
+      #   node.loc?(:begin)
+      #
+      #   # bad
+      #   node.loc.respond_to?(:begin) && node.loc.begin
+      #
+      #   # good
+      #   node.loc?(:begin)
+      #
+      #   # bad
+      #   node.loc.respond_to?(:begin) && node.loc.begin.is?('(')
+      #
+      #   # good
+      #   node.loc_is?(:begin, '(')
+      #
+      #   # bad
+      #   node.loc.respond_to?(:begin) && node.loc.begin.source == '('
+      #
+      #   # good
+      #   node.loc_is?(:begin, '(')
+      #
+      class LocationExists < Base
+        extend AutoCorrector
+
+        MSG = 'Use `node.loc?` instead of `loc.respond_to?`.'
+        MSG_CORRECTABLE = 'Use `%<replacement>s` instead of `%<source>s`.'
+        RESTRICT_ON_SEND = %i[respond_to?].freeze
+
+        # @!method loc_respond_to?(node)
+        def_node_matcher :loc_respond_to?, <<~PATTERN
+          (call
+            (call $_receiver :loc) :respond_to?
+            $(sym _location))
+        PATTERN
+
+        # @!method replaceable_with_loc_is(node)
+        def_node_matcher :replaceable_with_loc_is, <<~PATTERN
+          (and
+            (call
+              (call $_receiver :loc) :respond_to?
+              $(sym _location))
+            {
+              (call
+                (call
+                  (call _receiver :loc) _location) :is?
+                $(str _))
+              (call
+                (call
+                  (call
+                    (call _receiver :loc) _location) :source) :==
+                    $(str _))
+            })
+        PATTERN
+
+        # @!method replaceable_with_loc(node)
+        def_node_matcher :replaceable_with_loc, <<~PATTERN
+          (and
+            (call
+              (call $_receiver :loc) :respond_to?
+              $(sym _location))
+            (call
+              (call _receiver :loc) _location))
+        PATTERN
+
+        def on_and(node)
+          replace_with_loc(node) || replace_with_loc_is(node)
+        end
+
+        def on_send(node)
+          return if ignored_node?(node.parent)
+
+          loc_respond_to?(node) do |receiver, location|
+            register_offense(node, replacement(receiver, "loc?(#{location.source})"))
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def replace_with_loc(node)
+          replaceable_with_loc(node) do |receiver, location|
+            if node.parent&.assignment?
+              register_offense(node, replace_assignment(receiver, location))
+            else
+              register_offense(node, replacement(receiver, "loc?(#{location.source})"))
+            end
+          end
+        end
+
+        def replace_with_loc_is(node)
+          replaceable_with_loc_is(node) do |receiver, location, value|
+            replacement = replacement(receiver, "loc_is?(#{location.source}, #{value.source})")
+            register_offense(node, replacement)
+          end
+        end
+
+        def register_offense(node, replacement)
+          message = format(MSG_CORRECTABLE, replacement: replacement, source: node.source)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
+          end
+
+          ignore_node(node)
+        end
+
+        def replacement(receiver, rest)
+          "#{replace_receiver(receiver)}#{rest}"
+        end
+
+        def replace_assignment(receiver, location)
+          prefix = replace_receiver(receiver)
+
+          "#{prefix}loc#{dot(receiver)}#{location.value} if #{prefix}loc?(#{location.source})"
+        end
+
+        def replace_receiver(receiver)
+          return '' unless receiver
+
+          "#{receiver.source}#{dot(receiver)}"
+        end
+
+        def dot(node)
+          node.parent.loc.dot.source
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.0/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_processor.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module InternalAffairs
+      class NodePatternGroups
+        # AST Processor for NodePattern ASTs, for use with `InternalAffairs/NodePatternGroups`.
+        #
+        # Looks for sequences and subsequences where the first item is a `node_type` node,
+        # and converts them to `node_sequence` nodes (not a true `RuboCop::AST::NodePattern`
+        # node type).
+        #
+        # The resulting AST will be walked by `InternalAffairs::NodePatternGroups::ASTWalker`
+        # in order to find node types in a `union` node that can be rewritten as a node group.
+        #
+        # NOTE: The `on_*` methods in this class relate not to the normal node types but
+        # rather to the Node Pattern node types. Not every node type is handled.
+        #
+        class ASTProcessor
+          include ::AST::Processor::Mixin
+
+          def handler_missing(node)
+            node.updated(nil, process_children(node))
+          end
+
+          # Look for `sequence` and `subsequence` nodes that contain a `node_type` node as
+          # their first child. These are rewritten as `node_sequence` nodes so that it is
+          # possible to compare nodes while looking for replacement candidates for node groups.
+          # This is necessary so that extended patterns can be matched and replaced.
+          # ie. `{(send _ :foo ...) (csend _ :foo ...)}` can become `(call _ :foo ...)`
+          def on_sequence(node)
+            first_child = node.child
+
+            if first_child.type == :node_type
+              children = [first_child.child, *process_children(node, 1..)]
+
+              # The `node_sequence` node contains the `node_type` symbol as its first child,
+              # followed by all the other nodes contained in the `sequence` node.
+              # The location is copied from the sequence, so that the entire sequence can
+              # eventually be corrected in the cop.
+              n(:node_sequence, children, location: node.location)
+            else
+              node.updated(nil, process_children(node))
+            end
+          end
+          alias on_subsequence on_sequence
+
+          private
+
+          def n(type, children = [], properties = {})
+            NodePattern::Node.new(type, children, properties)
+          end
+
+          def process_children(node, range = 0..-1)
+            node.children[range].map do |child|
+              child.is_a?(::AST::Node) ? process(child) : child
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.0/lib/rubocop/cop/layout/empty_line_after_guard_clause.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Enforces empty line after guard clause.
+      #
+      # This cop allows `# :nocov:` directive after guard clause because
+      # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+      #
+      # [source,ruby]
+      # ----
+      # def foo
+      #   # :nocov:
+      #   return if condition
+      #   # :nocov:
+      #   bar
+      # end
+      # ----
+      #
+      # Refer to SimpleCov's documentation for more details:
+      # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo
+      #     return if need_return?
+      #     bar
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     return if need_return?
+      #
+      #     bar
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     return if something?
+      #     return if something_different?
+      #
+      #     bar
+      #   end
+      #
+      #   # also good
+      #   def foo
+      #     if something?
+      #       do_something
+      #       return if need_return?
+      #     end
+      #   end
+      class EmptyLineAfterGuardClause < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend Util
+
+        MSG = 'Add empty line after guard clause.'
+        END_OF_HEREDOC_LINE = 1
+        SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
+
+        def on_if(node)
+          return if correct_style?(node)
+          return if multiple_statements_on_line?(node)
+
+          if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
+            if next_line_empty_or_allowed_directive_comment?(heredoc_line(node, heredoc_node))
+              return
+            end
+
+            add_offense(heredoc_node.loc.heredoc_end) do |corrector|
+              autocorrect(corrector, heredoc_node)
+            end
+          else
+            return if next_line_empty_or_allowed_directive_comment?(node.last_line)
+
+            add_offense(offense_location(node)) { |corrector| autocorrect(corrector, node) }
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          node_range = if heredoc?(node)
+                         range_by_whole_lines(node.loc.heredoc_body)
+                       else
+                         range_by_whole_lines(node.source_range)
+                       end
+
+          next_line = node_range.last_line + 1
+          if next_line_allowed_directive_comment?(next_line)
+            node_range = processed_source.comment_at_line(next_line)
+          end
+
+          corrector.insert_after(node_range, "\n")
+        end
+
+        def correct_style?(node)
+          !contains_guard_clause?(node) ||
+            next_line_rescue_or_ensure?(node) ||
+            next_sibling_parent_empty_or_else?(node) ||
+            next_sibling_empty_or_guard_clause?(node)
+        end
+
+        def contains_guard_clause?(node)
+          node.if_branch&.guard_clause?
+        end
+
+        def next_line_empty_or_allowed_directive_comment?(line)
+          return true if next_line_empty?(line)
+
+          next_line = line + 1
+          next_line_allowed_directive_comment?(next_line) && next_line_empty?(next_line)
+        end
+
+        def next_line_empty?(line)
+          processed_source[line].blank?
+        end
+
+        def next_line_allowed_directive_comment?(line)
+          return false unless (comment = processed_source.comment_at_line(line))
+
+          DirectiveComment.new(comment).enabled? || simplecov_directive_comment?(comment)
+        end
+
+        def next_line_rescue_or_ensure?(node)
+          parent = node.parent
+          parent.nil? || parent.rescue_type? || parent.ensure_type?
+        end
+
+        def next_sibling_parent_empty_or_else?(node)
+          next_sibling = node.right_sibling
+          return true unless next_sibling.is_a?(AST::Node)
+
+          parent = next_sibling.parent
+
+          parent&.if_type? && parent.else?
+        end
+
+        def next_sibling_empty_or_guard_clause?(node)
+          next_sibling = node.right_sibling
+          return true if next_sibling.nil?
+
+          next_sibling.if_type? && contains_guard_clause?(next_sibling)
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def last_heredoc_argument(node)
+          n = last_heredoc_argument_node(node)
+          n = n.children.first while n.respond_to?(:begin_type?) && n.begin_type?
+
+          return n if heredoc?(n)
+          return unless n.respond_to?(:arguments)
+
+          n.arguments.each do |argument|
+            node = last_heredoc_argument(argument)
+            return node if node
+          end
+
+          last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        def last_heredoc_argument_node(node)
+          return node unless node.respond_to?(:if_branch)
+
+          if node.if_branch.and_type?
+            node.if_branch.children.first
+          elsif use_heredoc_in_condition?(node.condition)
+            node.condition
+          else
+            node.if_branch.children.last
+          end
+        end
+
+        def heredoc_line(node, heredoc_node)
+          heredoc_body = heredoc_node.loc.heredoc_body
+          num_of_heredoc_lines = heredoc_body.last_line - heredoc_body.first_line
+
+          node.last_line + num_of_heredoc_lines + END_OF_HEREDOC_LINE
+        end
+
+        def heredoc?(node)
+          node.respond_to?(:heredoc?) && node.heredoc?
+        end
+
+        def use_heredoc_in_condition?(condition)
+          condition.descendants.any? do |descendant|
+            descendant.respond_to?(:heredoc?) && descendant.heredoc?
+          end
+        end
+
+        def offense_location(node)
+          if node.loc?(:end)
+            node.loc.end
+          else
+            node
+          end
+        end
+
+        def multiple_statements_on_line?(node)
+          parent = node.parent
+          return false unless parent
+
+          parent.begin_type? && same_line?(node, node.right_sibling)
+        end
+
+        # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+        # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+        def simplecov_directive_comment?(comment)
+          SIMPLE_DIRECTIVE_COMMENT_PATTERN.match?(comment.text)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rubocop-1.82.0/lib/rubocop/cop/layout/end_alignment.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks whether the end keywords are aligned properly.
+      #
+      # Three modes are supported through the `EnforcedStyleAlignWith`
+      # configuration parameter:
+      #
+      # If it's set to `keyword` (which is the default), the `end`
+      # shall be aligned with the start of the keyword (if, class, etc.).
+      #
+      # If it's set to `variable` the `end` shall be aligned with the
+      # left-hand-side of the variable assignment, if there is one.
+      #
+      # If it's set to `start_of_line`, the `end` shall be aligned with the
+      # start of the line where the matching keyword appears.
+      #
+      # This `Layout/EndAlignment` cop aligns with keywords (e.g. `if`, `while`, `case`)
+      # by default. On the other hand, `Layout/BeginEndAlignment` cop aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default due to `||= begin` tends
+      # to align with the start of the line. `Layout/DefEndAlignment` cop also aligns with
+      # `EnforcedStyleAlignWith: start_of_line` by default.
+      # These style can be configured by each cop.
+      #
+      # @example EnforcedStyleAlignWith: keyword (default)
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   # good
+      #
+      #   variable = if true
+      #              end
+      #
+      #   variable =
+      #     if true
+      #     end
+      #
+      # @example EnforcedStyleAlignWith: variable
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   # good
+      #
+      #   variable = if true
+      #   end
+      #
+      #   variable =
+      #     if true
+      #     end
+      #
+      # @example EnforcedStyleAlignWith: start_of_line
+      #   # bad
+      #
+      #   variable = if true
+      #       end
+      #
+      #   puts(if true
+      #        end)
+      #
+      #   # good
+      #
+      #   variable = if true
+      #   end
+      #
+      #   puts(if true
+      #   end)
+      #
+      #   variable =
+      #     if true
+      #     end
+      class EndAlignment < Base
+        include CheckAssignment
+        include EndKeywordAlignment
+        include RangeHelp
+        extend AutoCorrector
+
+        def on_class(node)
+          check_other_alignment(node)
+        end
+
+        def on_sclass(node)
+          if node.parent&.assignment?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
+        end
+
+        def on_module(node)
+          check_other_alignment(node)
+        end
+
+        def on_if(node)
+          check_other_alignment(node) unless node.ternary?
+        end
+
+        def on_while(node)
+          check_other_alignment(node)
+        end
+
+        def on_until(node)
+          check_other_alignment(node)
+        end
+
+        def on_case(node)
+          if node.argument?
+            check_asgn_alignment(node.parent, node)
+          else
+            check_other_alignment(node)
+          end
+        end
+        alias on_case_match on_case
+
+        private
+
+        def autocorrect(corrector, node)
+          AlignmentCorrector.align_end(corrector, processed_source, node, alignment_node(node))
+        end
+
+        def check_assignment(node, rhs)
+          # If there are method calls chained to the right hand side of the
+          # assignment, we let rhs be the receiver of those method calls before
+          # we check if it's an if/unless/while/until.
+          return unless (rhs = first_part_of_call_chain(rhs))
+
+          # If `rhs` is a `begin` node, find the first non-`begin` child.
+          rhs = rhs.child_nodes.first while rhs.begin_type?
+
+          return unless rhs.conditional?
+          return if rhs.if_type? && rhs.ternary?
+
+          check_asgn_alignment(node, rhs)
+        end
+
+        def check_asgn_alignment(outer_node, inner_node)
+          align_with = {
+            keyword: inner_node.loc.keyword,
+            start_of_line: start_line_range(inner_node),
+            variable: asgn_variable_align_with(outer_node, inner_node)
+          }
+
+          check_end_kw_alignment(inner_node, align_with)
+          ignore_node(inner_node)
+        end
+
+        def asgn_variable_align_with(outer_node, inner_node)
+          expr = outer_node.source_range
+
+          if line_break_before_keyword?(expr, inner_node)
+            inner_node.loc.keyword
+          else
+            range_between(expr.begin_pos, inner_node.loc.keyword.end_pos)
+          end
+        end
+
+        def check_other_alignment(node)
+          align_with = {
+            keyword: node.loc.keyword,
+            variable: node.loc.keyword,
+            start_of_line: start_line_range(node)
+          }
+          check_end_kw_alignment(node, align_with)
+        end
+
+        def alignment_node(node)
+          case style
+          when :keyword
+            node
+          when :variable
+            align_to = alignment_node_for_variable_style(node)
+
+            while (parent = align_to.parent) && parent.send_type? && same_line?(align_to, parent)
+              align_to = parent
+            end
+
+            align_to
+          else
+            start_line_range(node)
+          end
+        end
+
+        def alignment_node_for_variable_style(node)
+          if node.type?(:case, :case_match) && node.argument? &&
+             same_line?(node, node.parent)
+            return node.parent
+          end
+
+          assignment = assignment_or_operator_method(node)
+
+          if assignment && !line_break_before_keyword?(assignment.source_range, node)
+            assignment
+          else
+            # Fall back to 'keyword' style if this node is not on the RHS of an
+            # assignment, or if it is but there's a line break between LHS and
+            # RHS.
+            node
+          end
+        end
+
+        def assignment_or_operator_method(node)
+          node.ancestors.find do |ancestor|
+            ancestor.assignment_or_similar? || (ancestor.send_type? && ancestor.operator_method?)
+          end
+        end
+      end
+    end
+  end
+end