Add guess mime type action

base/__init__.py

@@ -7,5 +7,6 @@ import gi
 gi.require_version('Gtk', '4.0')
 gi.require_version('Adw', '1')
 
+
 def create(api: ExtensionApi) -> Extension:
     return BaseExtension(api)

base/extension.py

@@ -8,40 +8,59 @@ from base.date_time.date_time import DateTime
 
 from base.date_time.date_time_view_factory import DateTimeViewFactory
 from base.file.file_view_factory import FileViewFactory
+from base.file.actions.guess_mime_type import \
+    GuessMimeTypeAction
 from base.image.image_view_factory import ImageViewFactory
 
+
 BASE_NAME = Path(__file__).parent.as_posix()
 
 
 class BaseExtension(Extension):
     def __init__(self, api: ExtensionApi):
         super().__init__('base', api, dependencies={'core'})
-        self.types = []
+        self.types = {}
+
+        self.view_factories = {
+            'DateTime': DateTimeViewFactory(),
+            'File': FileViewFactory(self._api.document_registry),
+            'Image': ImageViewFactory(self._api.document_registry),
+            'Url': UrlViewFactory(self._api.ui_service),
+        }
 
-        self.view_factories = [
-            DateTimeViewFactory(),
-            FileViewFactory(self._api.document_registry),
-            ImageViewFactory(self._api.document_registry),
-            UrlViewFactory(self._api.ui_service)
-        ]
+        self.actions = []
 
     def register_types(self):
-        self.types = [
-            DateTime.TYPE,
-            self._api.type_loader.load(BASE_NAME + '/file/file.json'),
-            self._api.type_loader.load(BASE_NAME + '/image/image.json'),
-            self._api.type_loader.load(BASE_NAME + '/url/url.json')
-        ]
+        self.types = {
+            'DateTime': DateTime.TYPE,
+            'File': self._api.type_loader.load(BASE_NAME + '/file/file.json'),
+            'Image': self._api.type_loader.load(BASE_NAME + '/image/image.json'),
+            'Url': self._api.type_loader.load(BASE_NAME + '/url/url.json'),
+        }
 
         self._api.type_registry.register_type(DateTime.TYPE)
 
     def deregister_types(self):
-        for t in self.types:
+        for t in self.types.values():
             self._api.type_registry.deregister_type(t)
 
+    def register_actions(self):
+        file_type = self.types['File']
+        guess_mime_type_action = GuessMimeTypeAction(
+            file_type,
+            self._api.resource_type_registry
+        )
+        self._api.action_registry.register_action(guess_mime_type_action)
+        self.actions.append(guess_mime_type_action)
+
+    def deregister_actions(self):
+        for action in self.actions:
+            self._api.action_registry.register_action(action)
+
     def register_view_factories(self):
         for specification in [Specification(), Specification(True)]:
-            for type, view_factory in zip(self.types, self.view_factories):
+            for type_name, view_factory in self.view_factories.items():
+                type = self.types[type_name]
                 if not view_factory.satisfies(specification):
                     continue
                 self._api.view_factory_registry.register_type_view_factory(
@@ -49,7 +68,8 @@ class BaseExtension(Extension):
 
     def deregister_view_factories(self):
         for specification in [Specification(), Specification(True)]:
-            for type, view_factory in zip(self.types, self.view_factories):
+            for type_name, view_factory in self.view_factories.items():
+                type = self.types[type_name]
                 if not view_factory.satisfies(specification):
                     continue
                 self._api.view_factory_registry.deregister_type_view_factory(

base/file/actions/guess_mime_type.py

+from blackfennec.action_system.action import Action
+from blackfennec.action_system.context import Context
+from ..file import File
+
+from blackfennec.document_system.mime_type.mime_type import MimeType
+from blackfennec.document_system.resource_type.resource_type import ResourceType
+from blackfennec.document_system.resource_type.resource_type_registry import \
+    ResourceTypeRegistry
+
+
+class GuessMimeTypeAction(Action):
+    def __init__(self, map_type, resource_type_registry: ResourceTypeRegistry):
+        super().__init__(map_type)
+        self._resource_type_registry: ResourceTypeRegistry = \
+            resource_type_registry
+
+    def execute(self, context: Context):
+        file_type = File(context.structure)
+        resource_type_id = ResourceType.try_determine_resource_type(file_type.file_path)
+        resource_type = self._resource_type_registry.resource_types[
+            resource_type_id
+        ]
+        mime_type = MimeType.try_determine_mime_type(
+            file_type.file_path, resource_type)
+        file_type.file_type = mime_type
+
+    @property
+    def name(self):
+        return "guess mime type"
+
+    @property
+    def description(self):
+        return """Tries to determine the mime type of a file."""

tests/file/actions/test_guess_mime_type.py

+import pytest
+
+from base.file.actions.guess_mime_type import GuessMimeTypeAction
+from blackfennec_doubles.action_system.double_context import ContextMock
+from blackfennec_doubles.document_system.resource_type.double_resource_type_registry import \
+    ResourceTypeRegistryMock
+from blackfennec_doubles.structure.double_map import MapMock
+from blackfennec_doubles.structure.double_string import StringMock
+
+from doubles.double_dummy import Dummy
+
+
+@pytest.fixture
+def type():
+    return Dummy()
+
+
+@pytest.fixture
+def resource_type_registry():
+    return ResourceTypeRegistryMock(resource_types={"file": Dummy()})
+
+
+@pytest.fixture
+def action(type, resource_type_registry):
+    return GuessMimeTypeAction(type, resource_type_registry)
+
+
+def test_can_construct(action):
+    assert action is not None
+
+
+def test_can_execute(action):
+    context = ContextMock()
+    context.structure = MapMock()
+    context.structure.value = {"file_path": StringMock("test.jpg")}
+    action.execute(context)
+    assert context.structure.value["file_type"].value == "image/jpeg"
+
+
+def test_is_correct_type(action, type):
+    assert action.type is type
+
+
+def test_has_correct_name(action):
+    assert action.name == "guess mime type"
+
+
+def test_has_correct_description(action):
+    assert len(action.description) > 7

tests/test_base_extension.py

 from base.extension import BaseExtension
 import pytest
 
+from blackfennec_doubles.action_system import ActionRegistryMock
 from blackfennec_doubles.double_dummy import Dummy
 from blackfennec_doubles.type_system.double_type_registry import \
     TypeRegistryMock
@@ -20,11 +21,12 @@ def extension_api():
         view_factory=Dummy('ViewFactory'),
         view_factory_registry=ViewFactoryRegistryMock(),
         type_loader=TypeLoaderMock(type_registry),
-        action_registry=Dummy('ActionRegistry'),
+        action_registry=ActionRegistryMock(),
         document_registry=Dummy('DocumentRegistry'),
         document_factory=Dummy('DocumentFactory'),
         ui_service=Dummy('UiService'),
         mime_type_registry=Dummy('MimeTypeRegistry'),
+        resource_type_registry=Dummy('ResourceTypeRegistry'),
     )
 
 

tests/test_entry_point.py

@@ -26,6 +26,7 @@ def extension_api():
         document_factory=Dummy('DocumentFactory'),
         ui_service=Dummy('UiService'),
         mime_type_registry=Dummy('MimeTypeRegistry'),
+        resource_type_registry=Dummy('ResourceTypeRegistry'),
     )