Compare 7de21ac ... +1 ... f4457b8

"""Methods for deducing and understanding indents."""

# We're in the utils module, but users will expect reflow

# logs to appear in the context of rules. Hence it's a subset

# of the rules logger.

    """Given a raw segment, deduce the indent of it's line."""

    else:

"""Static methods to support ReflowPoint.respace_point()."""

# We're in the utils module, but users will expect reflow

# logs to appear in the context of rules. Hence it's a subset

# of the rules logger.

    prev_block: Optional["ReflowBlock"],

    next_block: Optional["ReflowBlock"],

    strip_newlines: bool = False,

) -> Tuple[str, str, bool]:

    """Given the surrounding blocks, determine appropriate constraints."""

    # Start with the defaults.

    # Work out the common parent segment and depth

        # Just check the most immediate parent for now for speed.

        # TODO: Review whether just checking the parent is enough.

        # NOTE: spacing configs will be available on both sides if they're common

        # so it doesn't matter whether we get it from prev_block or next_block.

            # NOTE: inline is actually a more extreme version of "touch".

            # Examples:

            # - "inline" would be used with an object reference, where the

            #   parts have to all be together on one line like `a.b.c`.

            # - "touch" would allow the above layout, _but also_ allow an

            #   an optional line break between, much like between an opening

            #   bracket and the following element: `(a)` or:

            #   ```

            #   (

            #       a

            #   )

            #   ```

                # If they are then strip newlines.

            # If segments are expected to be touch within. Then modify

            # constraints accordingly.

            # NOTE: We don't override if it's already "any"

        else:  # pragma: no cover

            idx = prev_block.depth_info.stack_hashes.index(common[-1])

            raise NotImplementedError(

                f"Unexpected within constraint: {within_constraint} for "

                f"{prev_block.depth_info.stack_class_types[idx]}"

            )

    segment_buffer: List[RawSegment], strip_newlines: bool = False

) -> Tuple[List[RawSegment], Optional[RawSegment], List[LintFix]]:

    """Given the existing spacing, extract information and do basic pruning."""

    # Loop through the existing segments looking for spacing.

        # If it's whitespace, store it.

        # If it's a newline, react accordingly.

            # Are we stripping newlines?

                # Carry on as though it wasn't here.

            # Check if we've just passed whitespace. If we have, remove it

            # as trailing whitespace, both from the buffer and create a fix.

            # Regardless, unset last_whitespace.

            # We either just deleted it, or it's not relevant for any future

            # segments.

        # If we find multiple sequential whitespaces, it's the sign

        # that we've removed something. Only the first one should be

        # a valid indent (or the one we consider for constraints).

        # Remove all the following ones.

    # Turn the removal buffer updated segment buffer, last whitespace

    # and associated fixes.

        [s for s in segment_buffer if s not in removal_buffer],

        # We should have removed all other whitespace by now.

        last_whitespace[0] if last_whitespace else None,

        [LintFix.delete(s) for s in removal_buffer],

    )

    root_segment: BaseSegment,

    whitespace_seg: RawSegment,

    next_seg: RawSegment,

    segment_type: str,

    align_within: Optional[str],

    align_boundary: Optional[str],

) -> str:

    """Work out spacing for instance of an `align` constraint."""

    # Find the level of segment that we're aligning.

    # NOTE: Reverse slice

    # We've got a parent. Find some siblings.

        # Purge any siblings with a boundary between them

            ps.segment.is_type(align_boundary) for ps in parent_segment.path_to(sibling)

        ):

        else:

                "    Purging a sibling because they're blocked " "by a boundary: %s",

                sibling,

            )

    # Is the current indent the only one on the line?

        # Same line

        sibling.pos_marker.working_line_no == next_seg.pos_marker.working_line_no

        # And not same position (i.e. not self)

        and sibling.pos_marker.working_line_pos != next_seg.pos_marker.working_line_pos

        for sibling in siblings

    ):

    # Work out the current spacing before each.

            # NOTE: We're asserting that there must have been

            # a last_code. Otherwise this won't work.

                seg.pos_marker.working_loc == sibling.pos_marker.working_loc

                and last_code

            ):

                    "    loc for %s: %s from %s",

                    sibling,

                    loc,

                    last_code,

                )

        1 + max_desired_line_pos - whitespace_seg.pos_marker.working_line_pos

    )

        "    desired_space: %r (based on max line pos of %s)",

        desired_space,

        max_desired_line_pos,

    )

    pre_constraint: str,

    post_constraint: str,

    next_block: Optional["ReflowBlock"],

    root_segment: BaseSegment,

    segment_buffer: List[RawSegment],

    last_whitespace: RawSegment,

) -> Tuple[List[RawSegment], List[LintFix]]:

    """Check inline spacing is the right size.

    This forms one of the cases handled by .respace_point().

    This code assumes:

    - a ReflowPoint with no newlines.

    - a ReflowPoint which has _some_ whitespace.

    Given this we apply constraints to ensure the whitespace

    is of an appropriate size.

    """

    # Get some indices so that we can reference around them

    # Do we have either side set to "any"

        # In this instance - don't change anything.

        # e.g. this could mean there is a comment on one side.

    # Do we have either side set to "touch"?

        # In this instance - no whitespace is correct, This

        # means we should delete it.

            LintFix(

                "delete",

                anchor=last_whitespace,

            )

        )

    # Handle left alignment & singles

        post_constraint.startswith("align") and next_block

    ) or pre_constraint == post_constraint == "single":

        # Determine the desired spacing, either as alignment or as a single.

                "    Alignment Config: %s, %s, %s, %s",

                seg_type,

                align_within,

                align_boundary,

                next_block.segments[0].pos_marker.working_line_pos,

            )

                root_segment,

                last_whitespace,

                next_block.segments[0],

                seg_type,

                align_within,

                align_boundary,

            )

        else:

                LintFix(

                    "replace",

                    anchor=last_whitespace,

                    edit=[new_seg],

                )

            )

    raise NotImplementedError(  # pragma: no cover

        f"Unexpected Constraints: {pre_constraint}, {post_constraint}"

    )

    pre_constraint: str,

    post_constraint: str,

    prev_block: Optional["ReflowBlock"],

    next_block: Optional["ReflowBlock"],

    segment_buffer: List[RawSegment],

    existing_fixes: List[LintFix],

    anchor_on: str = "before",

) -> Tuple[List[RawSegment], List[LintFix], bool]:

    """Ensure spacing is the right size.

    This forms one of the cases handled by .respace_point().

    This code assumes:

    - a ReflowPoint with no newlines.

    - a ReflowPoint which _no_ whitespace.

    Given this we apply constraints to either confirm no

    spacing is required or create some of the right size.

    """

    # Do we have either side set to "touch" or "any"

        # In this instance - no whitespace is correct.

        # Either because there shouldn't be, or because "any"

        # means we shouldn't check.

    # Handle the default case

        # Insert a single whitespace.

        # Add it to the buffer first (the easy bit). The hard bit

        # is to then determine how to generate the appropriate LintFix

        # objects.

        # So special handling here. If segments either side

        # already exist then we don't care which we anchor on

        # but if one is already an insertion (as shown by a lack)

        # of pos_marker, then we should piggy back on that pre-existing

        # fix.

            if not existing_fixes:  # pragma: no cover

                raise ValueError(

                    "Fixes detected, but none passed to .respace(). "

                    "This will cause conflicts."

                )

            # Find the fix

                # Does it contain the insertion?

                # TODO: This feels ugly - eq for BaseSegment is different

                # to uuid matching for RawSegment. Perhaps this should be

                # more aligned. There might be a better way of doing this.

                    insertion

                    and fix.edit

                    and insertion.uuid in [elem.uuid for elem in fix.edit]

                ):

            else:  # pragma: no cover

                reflow_logger.warning("Fixes %s", existing_fixes)

                raise ValueError(f"Couldn't find insertion for {insertion}")

            # Mutate the existing fix

        else:

            # Take into account hint on where to anchor if given.

                    LintFix(

                        "create_after",

                        anchor=prev_block.segments[-1],

                        edit=[WhitespaceSegment()],

                    )

                )

                    LintFix(

                        "create_before",

                        anchor=next_block.segments[0],

                        edit=[WhitespaceSegment()],

                    )

                )

            else:  # pragma: no cover

                NotImplementedError(

                    "Not set up to handle a missing _after_ and _before_."

                )

    else:  # pragma: no cover

        # TODO: This will get test coverage when configuration routines

        # are in properly.

        raise NotImplementedError(

            f"Unexpected Constraints: {pre_constraint}, {post_constraint}"

        )

"""Static methods to support ReflowSequence.rebreak()."""

# We're in the utils module, but users will expect reflow

# logs to appear in the context of rules. Hence it's a subset

# of the rules logger.

    """A location within a sequence to consider rebreaking."""

    """Indices of points for a _RebreakLocation."""

        cls: Type["_RebreakIndices"],

        elements: ReflowSequenceType,

        start_idx: int,

        dir: int,

    ) -> "_RebreakIndices":

        """Iterate through the elements to deduce important point indices."""

        # Limit depends on the direction

        # The adjacent point is just the next one.

        # The newline point is next. We hop in 2s because we're checking

        # only points, which alternate with blocks.

                seg.is_code for seg in elements[newline_point_idx + dir].segments

            ):

        # Finally we look for the point preceding the next code element.

    """A location within a sequence to rebreak, with metadata."""

        cls: Type["_RebreakLocation"], span: _RebreakSpan, elements: ReflowSequenceType

    ) -> "_RebreakLocation":

        """Expand a span to a location."""

            span.target,

            _RebreakIndices.from_elements(elements, span.start_idx, -1),

            _RebreakIndices.from_elements(elements, span.end_idx, 1),

            span.line_position,

            span.strict,

        )

        """Is either side a templated newline?

        If either side has a templated newline, then that's ok too.

        The intent here is that if the next newline is a _templated_

        one, then in the source there will be a tag ({{ tag }}), which

        acts like _not having a newline_.

        """

        # Check the _last_ newline of the previous point.

        # Slice backward to search in reverse.

        # Check the _first_ newline of the next point.

        self, elements: ReflowSequenceType, strict: bool = False

    ) -> bool:

        """Is the span surrounded by one (but not two) line breaks?

        Args:

            elements: The elements of the ReflowSequence this element

               is taken from to allow comparison.

            strict (:obj:`bool`): If set to true, this will not allow

               the case where there aren't newlines on either side.

        """

        # Here we use the newline index, not

        # just the adjacent point, so that we can see past comments.

            # If there isn't a newline on either side then carry

            # on, unless it's strict.

            (newlines_on_neither_side and not strict)

            # If there is a newline on BOTH sides. That's ok.

            or newlines_on_both_sides

        )

    element_buffer: ReflowSequenceType, root_segment: BaseSegment

) -> List[_RebreakSpan]:

    """Identify areas in file to rebreak.

    A span here is a block, or group of blocks which have

    explicit configs for their line position, either directly

    as raw segments themselves or by virtue of one of their

    parent segments.

    """

    # We'll need at least two elements each side, so constrain

    # our range accordingly.

        # Only evaluate blocks:

        # Only evaluate blocks

        # Does the element itself have config? (The easy case)

            # Blocks should only have one segment so it's easy to pick it.

                _RebreakSpan(

                    elem.segments[0],

                    idx,

                    idx,

                    # NOTE: this isn't pretty but until it needs to be more

                    # complex, this works.

                    elem.line_position.split(":")[0],

                    elem.line_position.endswith("strict"),

                )

            )

        # Do any of its parents have config, and are we at the start

        # of them?

            # If we're not at the start of the segment, then pass.

            # Can we find the end?

                    # Found the end. Add it to the stack.

                    # We reference the appropriate element from the parent stack.

                        target_depth

                    ].segment

                        _RebreakSpan(

                            target,

                            idx,

                            end_idx,

                            # NOTE: this isn't pretty but until it needs to be more

                            # complex, this works.

                            elem.line_position_configs[key].split(":")[0],

                            elem.line_position_configs[key].endswith("strict"),

                        )

                    )

            # If we find the start, but not the end, it's not a problem, but

            # we won't be rebreaking this span. This is important so that we

            # don't rebreak part of something without the context of what's

            # in the rest of it. We continue without adding it to the buffer.

    elements: ReflowSequenceType, root_segment: BaseSegment

) -> Tuple[ReflowSequenceType, List[LintFix]]:

    """Reflow line breaks within a sequence.

    Initially this only _moves_ existing segments

    around line breaks (e.g. for operators and commas),

    but eventually this method should also handle line

    length considerations too.

    This intentionally does *not* handle indentation,

    as the existing indents are assumed to be correct.

    """

    # Given a sequence we should identify the objects which

    # make sense to rebreak. That includes any raws with config,

    # but also and parent segments which have config and we can

    # find both ends for. Given those spans, we then need to find

    # the points either side of them and then the blocks either

    # side to respace them at the same time.

    # 1. First find appropriate spans.

    # The spans give us the edges of operators, but for line positioning we need

    # to handle comments differently. There are two other important points:

    # 1. The next newline outward before code (but passing over comments).

    # 2. The point before the next _code_ segment (ditto comments).

    # Handle each span:

            "Handing Rebreak Span (%r: %s): %r",

            loc.line_position,

            loc.target,

            "".join(

                elem.raw

                for elem in elem_buff[

                    loc.prev.pre_code_pt_idx - 1 : loc.next.pre_code_pt_idx + 2

                ]

            ),

        )

        # Points and blocks either side are just offsets from the indices.

        # So we know we have a preference, is it ok?

                # We're good. It's already leading.

            # Is it the simple case with no comments between the

            # old and new desired locations and only a single following

            # whitespace?

                loc.next.adj_pt_idx == loc.next.pre_code_pt_idx

                and elem_buff[loc.next.newline_pt_idx].num_newlines() == 1

            ):

                # Simple case. No comments.

                # Strip newlines from the next point. Apply the indent to

                # the previous point.

                    next_point.get_indent() or "", before=loc.target

                )

                    cast(ReflowBlock, elem_buff[loc.next.adj_pt_idx - 1]),

                    cast(ReflowBlock, elem_buff[loc.next.adj_pt_idx + 1]),

                    root_segment=root_segment,

                    fixes=fixes,

                    strip_newlines=True,

                )

                # Update the points in the buffer

            else:

                # Otherwise we've got a tricky scenario where there are comments

                # to negotiate around. In this case, we _move the target_

                # rather than just adjusting the whitespace.

                # Delete the existing position of the target, and

                # the _preceding_ point.

                # We always reinsert after the first point, but respace

                # the inserted point to ensure it's the right size given

                # configs.

                    cast(ReflowBlock, elem_buff[loc.next.adj_pt_idx - 1]),

                    cast(ReflowBlock, elem_buff[loc.next.pre_code_pt_idx + 1]),

                    root_segment=root_segment,

                    fixes=fixes,

                    anchor_on="after",

                )

                    LintFix.create_after(

                        elem_buff[loc.next.pre_code_pt_idx].segments[-1],

                        [loc.target],

                    )

                )

                    elem_buff[: loc.prev.adj_pt_idx]

                    + elem_buff[loc.next.adj_pt_idx : loc.next.pre_code_pt_idx + 1]

                    + elem_buff[

                        loc.prev.adj_pt_idx + 1 : loc.next.adj_pt_idx

                    ]  # the target

                    + [new_point]

                    + elem_buff[loc.next.pre_code_pt_idx + 1 :]

                )

                # We're good, it's already trailing.

            # Is it the simple case with no comments between the

            # old and new desired locations and only one previous newline?

                loc.prev.adj_pt_idx == loc.prev.pre_code_pt_idx

                and elem_buff[loc.prev.newline_pt_idx].num_newlines() == 1

            ):

                # Simple case. No comments.

                # Strip newlines from the previous point. Apply the indent

                # to the next point.

                    prev_point.get_indent() or "", after=loc.target

                )

                    cast(ReflowBlock, elem_buff[loc.prev.adj_pt_idx - 1]),

                    cast(ReflowBlock, elem_buff[loc.prev.adj_pt_idx + 1]),

                    root_segment=root_segment,

                    fixes=fixes,

                    strip_newlines=True,

                )

                # Update the points in the buffer

            else:

                # Otherwise we've got a tricky scenario where there are comments

                # to negotiate around. In this case, we _move the target_

                # rather than just adjusting the whitespace.

                # Delete the existing position of the target, and

                # the _following_ point.

                # We always reinsert before the first point, but respace

                # the inserted point to ensure it's the right size given

                # configs.

                    cast(ReflowBlock, elem_buff[loc.prev.pre_code_pt_idx - 1]),

                    cast(ReflowBlock, elem_buff[loc.prev.adj_pt_idx + 1]),

                    root_segment=root_segment,

                    fixes=fixes,

                    anchor_on="before",

                )

                    LintFix.create_before(

                        elem_buff[loc.prev.pre_code_pt_idx].segments[0],

                        [loc.target],

                    )

                )

                    elem_buff[: loc.prev.pre_code_pt_idx]

                    + [new_point]

                    + elem_buff[

                        loc.prev.adj_pt_idx + 1 : loc.next.adj_pt_idx

                    ]  # the target

                    + elem_buff[loc.prev.pre_code_pt_idx : loc.prev.adj_pt_idx + 1]

                    + elem_buff[loc.next.adj_pt_idx + 1 :]

                )

            # If we get here we can assume that the element is currently

            # either leading or trailing and needs to be moved onto its

            # own line.

            # First handle the following newlines first (easy).

                    deduce_line_indent(loc.target.raw_segments[-1], root_segment),

                    after=loc.target,

                )

                # Update the point in the buffer

            # Then handle newlines before. (hoisting past comments if needed).

                # NOTE: In the case that there are comments _after_ the

                # target, they will be moved with it. This might break things

                # but there isn't an unambiguous way to do this, because we

                # can't be sure what the comments are referring to.

                # Given that, we take the simple option.

                    deduce_line_indent(loc.target.raw_segments[0], root_segment),

                    before=loc.target,

                )

                # Update the point in the buffer

        else:

            raise NotImplementedError(  # pragma: no cover

                f"Unexpected line_position config: {loc.line_position}"

            )