Python: type-sensitivity in `expectSelfie`

[nedtwigg]

Here are our docs for now:

selfie/selfie.dev/src/pages/py/get-started.mdx

Lines 38 to 48 in 7b31cc6

	Let's say we have the following test code:
	```python
	expectSelfie(str([1, 2, 3])).toBe_TODO()
	```
	If you run this test, selfie will rewrite your sourcecode to be this:
	```python
	expectSelfie(str([1, 2, 3])).toBe("[1, 2, 3]")
	```

Inside of expectSelfie, we can switch on the object type to return primitives, for example

selfie/jvm/selfie-lib/src/commonMain/kotlin/com/diffplug/selfie/SelfieImplementations.kt

Lines 288 to 293 in 7b31cc6

	class IntSelfie(private val actual: Int) {
	@JvmOverloads fun toBe_TODO(unusedArg: Any? = null) = toBeDidntMatch(null, actual, LiteralInt)
	fun toBe(expected: Int) =
	if (actual == expected) Selfie.system.checkSrc(actual)
	else toBeDidntMatch(expected, actual, LiteralInt)
	}

But for other things like an array or FooPerson, we have some design choices to make. We should probably call either __str__ or __repr__ on the object. I'm leaning towards __repr__.

https://chat.openai.com/share/b438ed63-4796-4418-89e1-eb055042e786

TBD!

[nedtwigg]

• Method name is expect_selfie, users can rename the import to expects for semi-compatibility with other fluent assertion libraries, especially https://github.com/gabrielfalcao/sure, but also https://github.com/assertpy/assertpy and https://github.com/drslump/pyshould
• expect_selfie returns a different type depending on what was passed in
• tobe vs to_be vs to.be
  • to.be.isEqual is drop-in compatible with sure, but super weird
  • to_be is the winner
• if it isn't handled in a special way (e.g. string, int), we should call __repr__ to make it into a string and use StringSelfie
  • TBD we could detect if is has its own __str__ or __repr__ to call those, or we could even make one ourselves
  • https://chat.openai.com/share/d3bed99f-0416-4dab-8fde-48435efe64a1

[nedtwigg]

Example code:

def expect_selfie(actual):
    if isinstance(actual, int):
        return IntSelfie(actual)
    elif isinstance(actual, bool):
        return BooleanSelfie(actual)
    elif isinstance(actual, str):
        return _expect_selfie_string(actual)
    else:
        return _expect_selfie_string(actual.__repr__())


def _expect_selfie_string(actual: str):
    snapshot = Snapshot.of(actual)
    diskStorage = _selfieSystem().disk_thread_local()
    return StringSelfie(snapshot, diskStorage)

[nedtwigg]

Everything in python has a __repr__ method which tries to return Python source code which evaluates to the object in question. It works great for all the python built-in types.

This lets implement all of our LiteralFormat stuff with just repr() and eval(). Much simpler. We keep our int encoder to put the underscores in to make the numbers more readable.

StringSelfie now extends ReprSelfie[String], and the to-be-implemented BinarySelfie will extend ReprSelfie[bytes].