Add skipif option

Author: kalekseev

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ### Unreleased
 
+### dev
+
+- Add option `skipif` that accepts user function
+- Deprecate `ignore_types`
+
 ### 0.9.1
 
 - Replace DeprecationWarning with FutureWarning for `@ignore_checks`

README.md

@@ -50,16 +50,32 @@ class MyModel(models.Model):
         ...
 ```
 
-Another way is to specify type of the object that need to be ignored in `ignore_types` option:
+Another way is to provide function that accepts field, model or
+serializer class as its first argument and returns `True` if it must be skipped.
+_Be aware that the more computation expensive your skipif functions the
+slower django check will run._
+
+`skipif` example:
 
 ```python
+def skipif_streamfield(field, *args, **kwargs):
+    return isinstance(field, wagtail.core.fields.StreamField)
+
+def skipif_non_core_app(model_cls, *args, **kwargs):
+    return model_cls._meta.app_label != "my_core_app"
+
 EXTRA_CHECKS = {
     "check": [
         {
             "id": "field-verbose-name-gettext",
             # make this check skip wagtail's StreamField
-            "ignore_types": ["wagtail.core.fields.StreamField"],
-        }
+            "skipif": skipif_streamfield
+        },
+        {
+            "id": "model-admin",
+            # models from non core app shouldn't be registered in admin
+            "skipif": skipif_non_core_app,
+        },
     ]
 }
 ```

src/extra_checks/checks/base_checks.py

@@ -1,5 +1,5 @@
 from abc import ABC
-from typing import TYPE_CHECKING, Any, ClassVar, Iterator, Optional, Set, Type
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Iterator, Optional, Set, Type
 
 import django.core.checks
 
@@ -25,10 +25,12 @@ def __init__(
         level: Optional[int] = None,
         ignore_objects: Optional[Set[Any]] = None,
         ignore_types: Optional[set] = None,
+        skipif: Optional[Callable] = None,
     ) -> None:
         self.level = level or self.level
         self.ignore_objects = ignore_objects or set()
         self.ignore_types = ignore_types or set()
+        self.skipif = skipif
 
     def __call__(
         self, obj: Any, ast: Optional[DisableCommentProtocol] = None, **kwargs: Any
@@ -39,6 +41,8 @@ def __call__(
                     yield error
 
     def is_ignored(self, obj: Any) -> bool:
+        if self.skipif and self.skipif(obj):
+            return True
         return obj in self.ignore_objects or type(obj) in self.ignore_types
 
     def message(

src/extra_checks/checks/model_field_checks.py

@@ -33,6 +33,8 @@ def __call__(
             pass
 
     def is_ignored(self, obj: Any) -> bool:
+        if self.skipif and self.skipif(obj):
+            return True
         return obj.model in self.ignore_objects or type(obj) in self.ignore_types
 
 

src/extra_checks/forms.py

@@ -1,5 +1,6 @@
 import importlib
 import typing
+import warnings
 
 import django.core.checks
 from django import forms
@@ -35,6 +36,21 @@ def validate(self, value: list) -> None:
             self.base_field.validate(val)
 
 
+class FilterField(forms.Field):
+    default_error_messages = {
+        "invalid_callable": _("%(value)s is not valid callable for skipif."),
+    }
+
+    def to_python(self, value: typing.Any) -> typing.Optional[typing.Callable]:
+        if not value:
+            return None
+        if not callable(value):
+            raise forms.ValidationError(
+                self.error_messages["invalid_callable"], code="invalid_callable"
+            )
+        return value
+
+
 class UnionField(forms.Field):
     default_error_messages = {
         "type_invalid": _("%(value)s is not one of the available types."),
@@ -176,6 +192,7 @@ class BaseCheckForm(forms.Form):
         required=False,
     )
     ignore_types = ListField(forms.CharField(), required=False)
+    skipif = FilterField(required=False)
 
     def clean_level(self) -> typing.Optional[int]:
         if self.cleaned_data["level"]:
@@ -195,6 +212,11 @@ def clean_ignore_types(self) -> set:
                 raise forms.ValidationError(
                     f"ignore_types contains entry that can't be imported: '{import_path}'."
                 )
+        if result:
+            warnings.warn(
+                "ignore_types is deprecated and will be removed in version 0.11.0, replace it with skipif option.",
+                FutureWarning,
+            )
         return result
 
     def clean(self) -> typing.Dict[str, typing.Any]:
@@ -203,6 +225,8 @@ def clean(self) -> typing.Dict[str, typing.Any]:
             and not self.cleaned_data["ignore_types"]
         ):
             del self.cleaned_data["ignore_types"]
+        if "skipif" in self.cleaned_data and not self.cleaned_data["skipif"]:
+            del self.cleaned_data["skipif"]
         return self.cleaned_data
 
 

tests/example/models.py

@@ -21,9 +21,11 @@ class Article(models.Model):
     author = models.ForeignKey(
         Author, related_name="articles", on_delete=models.CASCADE
     )
+    created = models.DateTimeField(auto_now=True)
 
     class Meta:
         verbose_name = "Site Article"
+        get_latest_by = ["created"]
 
 
 class NestedField(models.Field):

tests/test_ignore.py

@@ -1,3 +1,4 @@
+import django.db.models
 import pytest
 
 from extra_checks.checks import model_checks, model_field_checks
@@ -94,3 +95,52 @@ def test_field_ignore_types(test_case):
     )
     assert len(messages) == 1
     assert {m.obj.name for m in messages} == {"file_fail"}
+
+
+def test_field_skipif(test_case):
+    def skipif(field, *args, **kwargs):
+        return isinstance(field, django.db.models.ImageField)
+
+    messages = (
+        test_case.settings(
+            {
+                "checks": [
+                    {
+                        "id": model_field_checks.CheckFieldFileUploadTo.Id.value,
+                        "skipif": skipif,
+                    }
+                ],
+            }
+        )
+        .models(models.ModelFieldFileUploadTo)
+        .check(model_field_checks.CheckFieldFileUploadTo)
+        .run()
+    )
+    assert len(messages) == 1
+    assert {m.obj.name for m in messages} == {"file_fail"}
+
+
+def test_model_skipif(test_case):
+    def skipif(model, *args, **kwargs):
+        return not any(
+            isinstance(f, django.db.models.DateTimeField)
+            for f in model._meta.get_fields()
+        )
+
+    messages = (
+        test_case.settings(
+            {
+                "checks": [
+                    {
+                        "id": model_checks.CheckModelMetaAttribute.Id.value,
+                        "attrs": ["get_latest_by"],
+                        "skipif": skipif,
+                    },
+                ],
+            }
+        )
+        .models(models.Article, models.Author)
+        .check(model_checks.CheckModelMetaAttribute)
+        .run()
+    )
+    assert len(messages) == 0