refactor: Rename conditions as suggested by @mateocpdev

Author: EnriqueSoria

django_lifecycle/conditions/__init__.py

@@ -10,36 +10,36 @@
 
 
 __all__ = [
-    "WhenFieldWas",
-    "WhenFieldIsNow",
+    "WhenFieldValueWas",
+    "WhenFieldValueIs",
     "WhenFieldHasChanged",
-    "WhenFieldIsNot",
-    "WhenFieldWasNot",
-    "WhenFieldChangesTo",
+    "WhenFieldValueIsNot",
+    "WhenFieldValueWasNot",
+    "WhenFieldValueChangesTo",
     "Always",
 ]
 
 
 @dataclass
-class WhenFieldWas(ChainableCondition):
+class WhenFieldValueWas(ChainableCondition):
     field_name: str
-    was: Any = "*"
+    value: Any = "*"
 
     def __call__(
         self, instance: Any, update_fields: Union[Iterable[str], None] = None
     ) -> bool:
-        return self.was in (instance.initial_value(self.field_name), "*")
+        return self.value in (instance.initial_value(self.field_name), "*")
 
 
 @dataclass
-class WhenFieldIsNow(ChainableCondition):
+class WhenFieldValueIs(ChainableCondition):
     field_name: str
-    is_now: Any = "*"
+    value: Any = "*"
 
     def __call__(
         self, instance: Any, update_fields: Union[Iterable[str], None] = None
     ) -> bool:
-        return self.is_now in (instance._current_value(self.field_name), "*")
+        return self.value in (instance._current_value(self.field_name), "*")
 
 
 @dataclass
@@ -63,37 +63,37 @@ def __call__(
 
 
 @dataclass
-class WhenFieldIsNot(ChainableCondition):
+class WhenFieldValueIsNot(ChainableCondition):
     field_name: str
-    is_not: Any = NotSet
+    value: Any = NotSet
 
     def __call__(
         self, instance: Any, update_fields: Union[Iterable[str], None] = None
     ) -> bool:
         return (
-            self.is_not is NotSet
-            or instance._current_value(self.field_name) != self.is_not
+            self.value is NotSet
+            or instance._current_value(self.field_name) != self.value
         )
 
 
 @dataclass
-class WhenFieldWasNot(ChainableCondition):
+class WhenFieldValueWasNot(ChainableCondition):
     field_name: str
-    was_not: Any = NotSet
+    value: Any = NotSet
 
     def __call__(
         self, instance: Any, update_fields: Union[Iterable[str], None] = None
     ) -> bool:
         return (
-            self.was_not is NotSet
-            or instance.initial_value(self.field_name) != self.was_not
+            self.value is NotSet
+            or instance.initial_value(self.field_name) != self.value
         )
 
 
 @dataclass
-class WhenFieldChangesTo(ChainableCondition):
+class WhenFieldValueChangesTo(ChainableCondition):
     field_name: str
-    changes_to: Any = NotSet
+    value: Any = NotSet
 
     def __call__(
         self, instance: Any, update_fields: Union[Iterable[str], None] = None
@@ -106,12 +106,12 @@ def __call__(
             return False
 
         value_has_changed = bool(
-            instance.initial_value(self.field_name) != self.changes_to
+            instance.initial_value(self.field_name) != self.value
         )
         new_value_is_the_expected = bool(
-            instance._current_value(self.field_name) == self.changes_to
+            instance._current_value(self.field_name) == self.value
         )
-        return self.changes_to is NotSet or (
+        return self.value is NotSet or (
             value_has_changed and new_value_is_the_expected
         )
 

django_lifecycle/conditions/legacy.py

@@ -7,12 +7,12 @@
 
 from django_lifecycle import NotSet
 from django_lifecycle.conditions.base import ChainableCondition
-from django_lifecycle.conditions import WhenFieldChangesTo
+from django_lifecycle.conditions import WhenFieldValueChangesTo
 from django_lifecycle.conditions import WhenFieldHasChanged
-from django_lifecycle.conditions import WhenFieldIsNot
-from django_lifecycle.conditions import WhenFieldIsNow
-from django_lifecycle.conditions import WhenFieldWas
-from django_lifecycle.conditions import WhenFieldWasNot
+from django_lifecycle.conditions import WhenFieldValueIsNot
+from django_lifecycle.conditions import WhenFieldValueIs
+from django_lifecycle.conditions import WhenFieldValueWas
+from django_lifecycle.conditions import WhenFieldValueWasNot
 
 
 @dataclass
@@ -32,23 +32,23 @@ def __call__(self, instance: Any, update_fields=None) -> bool:
         if not has_changed_condition(instance, update_fields=update_fields):
             return False
 
-        changes_to_condition = WhenFieldChangesTo(self.when, changes_to=self.changes_to)
+        changes_to_condition = WhenFieldValueChangesTo(self.when, value=self.changes_to)
         if not changes_to_condition(instance, self.when):
             return False
 
-        is_now_condition = WhenFieldIsNow(self.when, is_now=self.is_now)
+        is_now_condition = WhenFieldValueIs(self.when, value=self.is_now)
         if not is_now_condition(instance, self.when):
             return False
 
-        was_condition = WhenFieldWas(self.when, was=self.was)
+        was_condition = WhenFieldValueWas(self.when, value=self.was)
         if not was_condition(instance, self.when):
             return False
 
-        was_not_condition = WhenFieldWasNot(self.when, was_not=self.was_not)
+        was_not_condition = WhenFieldValueWasNot(self.when, value=self.was_not)
         if not was_not_condition(instance, self.when):
             return False
 
-        is_not_condition = WhenFieldIsNot(self.when, is_not=self.is_not)
+        is_not_condition = WhenFieldValueIsNot(self.when, value=self.is_not)
         if not is_not_condition(instance, self.when):
             return False
 

django_lifecycle/mixins.py

@@ -145,7 +145,7 @@ def getitem(obj, field_name: str):
 
     def initial_value(self, field_name: str) -> Any:
         """
-        Get initial value of field when model was instantiated.
+        Get initial value of field when model value instantiated.
         """
         field_name = self._sanitize_field_name(field_name)
 
@@ -156,7 +156,7 @@ def initial_value(self, field_name: str) -> Any:
 
     def has_changed(self, field_name: str) -> bool:
         """
-        Check if a field has changed since the model was instantiated.
+        Check if a field has changed since the model value instantiated.
         """
         changed = self._diff_with_initial.keys()
         field_name = self._sanitize_field_name(field_name)

docs/hooks_and_conditions.md

@@ -50,25 +50,25 @@ state of a model instance's fields.
 
 There are some conditions already implemented, but you can provide your own condition, or even chain them using `&` and `|`.
 
- - `WhenFieldChangesTo(field_name, has_changed)`
- - `WhenFieldIsNow(field_name, is_now)`
- - `WhenFieldIsNot(field_name, is_not)`
- - `WhenFieldWas(field_name, was)`
- - `WhenFieldWasNot(field_name, was_not)`
- - `WhenFieldChangesTo(field_name, changes_to)`
+ - `WhenFieldHasChanged(field_name, has_changed)`
+ - `WhenFieldValueIs(field_name, value)`
+ - `WhenFieldValueIsNot(field_name, value)`
+ - `WhenFieldValueWas(field_name, value)`
+ - `WhenFieldValueWasNot(field_name, value)`
+ - `WhenFieldValueChangesTo(field_name, value)`
 
 ### Chaining conditions
 Conditions can be chained using `&` and `|` boolean operators
 
 ```python
-from django_lifecycle.conditions import WhenFieldChangesTo
+from django_lifecycle.conditions import WhenFieldValueChangesTo
 from django_lifecycle import hook, BEFORE_UPDATE
 
 @hook(
     BEFORE_UPDATE, 
     condition=(
-        WhenFieldChangesTo("first_name", changes_to="Ned") 
-        & WhenFieldChangesTo("last_name", changes_to="Flanders")
+        WhenFieldValueChangesTo("first_name", value="Ned")
+        & WhenFieldValueChangesTo("last_name", value="Flanders")
     )
 )
 def do_something(self):

tests/testapp/models.py

@@ -59,9 +59,7 @@ def timestamp_joined_at(self):
     @hook("after_create", on_commit=True)
     def do_after_create_jobs(self):
         # queue background job to process thumbnail image...
-        mail.send_mail(
-            "Welcome!", "Thank you for joining.", "[email protected]", ["[email protected]"]
-        )
+        mail.send_mail("Welcome!", "Thank you for joining.", "[email protected]", ["[email protected]"])
 
     @staticmethod
     def build_email_changed_body(old_email, new_email):
@@ -71,21 +69,23 @@ def build_email_changed_body(old_email, new_email):
     def notify_email_changed(self):
         mail.send_mail(
             subject="Email changed succesfully",
-            message=self.build_email_changed_body(old_email=self.initial_value('email'), new_email=self.email),
+            message=self.build_email_changed_body(
+                old_email=self.initial_value("email"), new_email=self.email
+            ),
             from_email="[email protected]",
-            recipient_list=["[email protected]"]
+            recipient_list=["[email protected]"],
         )
 
     @hook("before_update", when="password", has_changed=True)
     def timestamp_password_change(self):
         self.password_updated_at = timezone.now()
 
-    @hook('before_update', when='first_name', has_changed=True)
-    @hook('before_update', when='last_name', has_changed=True)
+    @hook("before_update", when="first_name", has_changed=True)
+    @hook("before_update", when="last_name", has_changed=True)
     def count_name_changes(self):
         self.name_changes += 1
 
-    @hook("before_delete", when='has_trial', was='*', is_now=True)
+    @hook("before_delete", when="has_trial", was="*", is_now=True)
     def ensure_trial_not_active(self):
         raise CannotDeleteActiveTrial("Cannot delete trial user!")
 
@@ -170,12 +170,7 @@ def answer_to_the_ultimate_question_of_life(self):
 
 class ModelWithGenericForeignKey(LifecycleModel):
     tag = models.SlugField()
-    content_type = models.ForeignKey(
-        ContentType,
-        on_delete=models.CASCADE,
-        blank=True,
-        null=True
-    )
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE, blank=True, null=True)
     object_id = models.PositiveIntegerField(blank=True, null=True)
     content_object = GenericForeignKey("content_type", "object_id")