selfie_lib.SourceFile.SourceFile Class Reference

Classes
class	ToBeLiteral

Public Member Functions
None	__init__ (self, str filename, str content)
	remove_selfie_once_comments (self)
str	as_string (self)
Slice	find_on_line (self, str to_find, int line_one_indexed)
None	replace_on_line (self, int line_one_indexed, str find, str replace)
ToBeLiteral	parse_to_be_like (self, int line_one_indexed)

Public Attributes
	TRIPLE_QUOTE

Static Public Attributes
str	TRIPLE_QUOTE = '"""'

Protected Member Functions
	_parse_code (self, int line_one_indexed, int arg_start, str dot_fun_open_paren)
	_parse_string (self, int line_one_indexed, int arg_start, str dot_fun_open_paren)

Protected Attributes
	_content_slice

Detailed Description

Definition at line 8 of file SourceFile.py.

Constructor & Destructor Documentation

__init__()

None selfie_lib.SourceFile.SourceFile.__init__	(		self,
		str	filename,
		str	content
	)

Definition at line 11 of file SourceFile.py.

    def __init__(self, filename: str, content: str) -> None:
        self.__unix_newlines: bool = "\r" not in content
        self._content_slice: Slice = Slice(content.replace("\r\n", "\n"))
        self.__language: Language = Language.from_filename(filename)
        self.__escape_leading_whitespace = EscapeLeadingWhitespace.appropriate_for(
            self._content_slice.__str__()
        )
 

Member Function Documentation

_parse_code()

selfie_lib.SourceFile.SourceFile._parse_code (   self, int  line_one_indexed, int  arg_start, str  dot_fun_open_paren  )

protected

Definition at line 177 of file SourceFile.py.

    ):
        # Initialize variables
        parenthesis_count = 1
        string_delimiter = None
 
        # Iterate through the characters starting from the given index
        for i in range(arg_start, len(self._content_slice)):
            char = self._content_slice[i]
 
            # Check if we are entering or leaving a string
            if char in ["'", '"'] and self._content_slice[i - 1] != "\\":
                if not string_delimiter:
                    string_delimiter = char
                elif char == string_delimiter:
                    string_delimiter = None
 
            # Skip characters inside strings
            if string_delimiter:
                continue
 
            # Count parentheses
            if char == "(":
                parenthesis_count += 1
            elif char == ")":
                parenthesis_count -= 1
 
            # If all parentheses are closed, return the current index
            if parenthesis_count == 0:
                end_paren = i
                end_arg = i
                return (end_paren, end_arg)
        # else ...
        raise AssertionError(
            f"Appears to be an unclosed function call `{dot_fun_open_paren}` "
            f"starting at line {line_one_indexed}"
        )
 

_parse_string()

selfie_lib.SourceFile.SourceFile._parse_string (   self, int  line_one_indexed, int  arg_start, str  dot_fun_open_paren  )

protected

Definition at line 219 of file SourceFile.py.

    ):
        if self._content_slice.subSequence(
            arg_start, len(self._content_slice)
        ).starts_with(self.TRIPLE_QUOTE):
            end_arg = self._content_slice.indexOf(
                self.TRIPLE_QUOTE, arg_start + len(self.TRIPLE_QUOTE)
            )
            if end_arg == -1:
                raise AssertionError(
                    f"Appears to be an unclosed multiline string literal `{self.TRIPLE_QUOTE}` "
                    f"on line {line_one_indexed}"
                )
            else:
                end_arg += len(self.TRIPLE_QUOTE)
                end_paren = end_arg
        else:
            end_arg = arg_start + 1
            while (
                self._content_slice[end_arg] != '"'
                or self._content_slice[end_arg - 1] == "\\"
            ):
                end_arg += 1
                if end_arg == self._content_slice.__len__():
                    raise AssertionError(
                        f'Appears to be an unclosed string literal `"` '
                        f"on line {line_one_indexed}"
                    )
            end_arg += 1
            end_paren = end_arg
        while self._content_slice[end_paren] != ")":
            if not self._content_slice[end_paren].isspace():
                raise AssertionError(
                    f"Non-primitive literal in `{dot_fun_open_paren}` starting at "
                    f"line {line_one_indexed}: error for character "
                    f"`{self._content_slice[end_paren]}` on line "
                    f"{self._content_slice.baseLineAtOffset(end_paren)}"
                )
            end_paren += 1
            if end_paren == self._content_slice.__len__():
                raise AssertionError(
                    f"Appears to be an unclosed function call `{dot_fun_open_paren}` "
                    f"starting at line {line_one_indexed}"
                )
        return (end_paren, end_arg)
 
 

as_string()

str selfie_lib.SourceFile.SourceFile.as_string

(

self

)

Definition at line 49 of file SourceFile.py.

    def as_string(self) -> str:
        return (
            self._content_slice.__str__()
            if self.__unix_newlines
            else self._content_slice.__str__().replace("\n", "\r\n")
        )
 

find_on_line()

Slice selfie_lib.SourceFile.SourceFile.find_on_line	(		self,
		str	to_find,
		int	line_one_indexed
	)

Definition at line 113 of file SourceFile.py.

    def find_on_line(self, to_find: str, line_one_indexed: int) -> Slice:
        line_content = self._content_slice.unixLine(line_one_indexed)
        idx = line_content.indexOf(to_find)
        if idx == -1:
            raise AssertionError(
                f"Expected to find `{to_find}` on line {line_one_indexed}, but there was only `{line_content}`"
            )
        return line_content.subSequence(idx, idx + len(to_find))
 

parse_to_be_like()

ToBeLiteral selfie_lib.SourceFile.SourceFile.parse_to_be_like	(		self,
		int	line_one_indexed
	)

Definition at line 129 of file SourceFile.py.

    def parse_to_be_like(self, line_one_indexed: int) -> ToBeLiteral:
        line_content = self._content_slice.unixLine(line_one_indexed)
        dot_fun_open_paren = None
 
        for to_be_like in TO_BE_LIKES:
            idx = line_content.indexOf(to_be_like)
            if idx != -1:
                dot_fun_open_paren = to_be_like
                break
        if dot_fun_open_paren is None:
            raise AssertionError(
                f"Expected to find inline assertion on line {line_one_indexed}, but there was only `{line_content}`"
            )
 
        dot_function_call_in_place = line_content.indexOf(dot_fun_open_paren)
        dot_function_call = dot_function_call_in_place + line_content.startIndex
        arg_start = dot_function_call + len(dot_fun_open_paren)
 
        if self._content_slice.__len__() == arg_start:
            raise AssertionError(
                f"Appears to be an unclosed function call `{dot_fun_open_paren}` "
                f"on line {line_one_indexed}"
            )
        while self._content_slice[arg_start].isspace():
            arg_start += 1
            if self._content_slice.__len__() == arg_start:
                raise AssertionError(
                    f"Appears to be an unclosed function call `{dot_fun_open_paren}` "
                    f"on line {line_one_indexed}"
                )
 
        if self._content_slice[arg_start] == '"':
            (end_paren, end_arg) = self._parse_string(
                line_one_indexed, arg_start, dot_fun_open_paren
            )
        else:
            (end_paren, end_arg) = self._parse_code(
                line_one_indexed, arg_start, dot_fun_open_paren
            )
        return self.ToBeLiteral(
            self,
            dot_fun_open_paren.replace("_TODO", ""),
            self._content_slice.subSequence(dot_function_call, end_paren + 1),
            self._content_slice.subSequence(arg_start, end_arg),
            self.__language,
            self.__escape_leading_whitespace,
        )
 

remove_selfie_once_comments()

selfie_lib.SourceFile.SourceFile.remove_selfie_once_comments

(

self

)

Definition at line 19 of file SourceFile.py.

    def remove_selfie_once_comments(self):
        # Split content into lines
        lines = self._content_slice.__str__().split("\n")
 
        # Create a new list of lines, excluding lines containing '# selfieonce' or '#selfieonce'
        new_lines = []
        for line in lines:
            # Check for both variations of the comment
            if "# selfieonce" in line:
                cleaned_line = line.split("# selfieonce")[0].strip()
            elif "#selfieonce" in line:
                cleaned_line = line.split("#selfieonce")[0].strip()
            else:
                new_lines.append(line)
                continue
 
            # If the line has code before the comment, keep the code part
            if cleaned_line:
                new_lines.append(cleaned_line)
 
        # Recombine the lines into a single string
        new_content = "\n".join(new_lines)
 
        # Update the content slice with new content
        self._content_slice = Slice(new_content)
 
        if not self.__unix_newlines:
            self._content_slice = Slice(new_content.replace("\n", "\r\n"))
 

replace_on_line()

None selfie_lib.SourceFile.SourceFile.replace_on_line	(		self,
		int	line_one_indexed,
		str	find,
		str	replace
	)

Definition at line 122 of file SourceFile.py.

    def replace_on_line(self, line_one_indexed: int, find: str, replace: str) -> None:
        assert "\n" not in find
        assert "\n" not in replace
 
        found = self.find_on_line(find, line_one_indexed)
        self._content_slice = Slice(found.replaceSelfWith(replace))
 

Member Data Documentation

_content_slice

selfie_lib.SourceFile.SourceFile._content_slice

protected

Definition at line 43 of file SourceFile.py.

TRIPLE_QUOTE [1/2]

str selfie_lib.SourceFile.SourceFile.TRIPLE_QUOTE = '"""'

static

Definition at line 9 of file SourceFile.py.

TRIPLE_QUOTE [2/2]

selfie_lib.SourceFile.SourceFile.TRIPLE_QUOTE

Definition at line 227 of file SourceFile.py.

---

The documentation for this class was generated from the following file:

• selfie-lib/selfie_lib/SourceFile.py