Merge pull request #280 from bridadan/replace_name_filter_with_function

Replace name filter with function

Author: theotherjimmy

mbed_lstools/lstools_base.py

@@ -109,14 +109,15 @@ def list_mbeds_ext(self):
 
     def list_mbeds(
             self, fs_interaction=FSInteraction.BeforeFilter,
-            platform_name_filters=[], unique_names=False,
+            filter_function=None, unique_names=False,
             read_details_txt=False):
         """ List details of connected devices
         @return Returns list of structures with detailed info about each mbed
         @param fs_interaction A member of the FSInteraction class that picks the
           trade of between quality of service and speed
-        @param platform_name_filters A series of regular expressions to filter
-          filter targets by
+        @param filter_function Function that is passed each mbed candidate,
+          should return True if it should be included in the result
+          Ex. mbeds = list_mbeds(filter_function=lambda m: m['platform_name'] == 'K64F')
         @param unique_names A boolean controlling the presence of the
           'platform_unique_name' member of the output dict
         @param read_details_text A boolean controlling the presense of the
@@ -128,8 +129,6 @@ def list_mbeds(
         candidates = list(self.find_candidates())
         logger.debug("Candidates for display %r", candidates)
         result = []
-        platform_name_matcher = re.compile("|".join("({})".format(pf) for pf
-                                                    in platform_name_filters))
         for device in candidates:
             if  ((not device['mount_point'] or
                   not self.mount_point_ready(device['mount_point'])) and
@@ -144,7 +143,7 @@ def list_mbeds(
                     FSInteraction.BeforeFilter: self._fs_before_id_check,
                     FSInteraction.AfterFilter: self._fs_after_id_check,
                     FSInteraction.Never: self._fs_never
-                }[fs_interaction](device, platform_name_matcher)
+                }[fs_interaction](device, filter_function)
                 if maybe_device:
                     if unique_names:
                         name = device['platform_name']
@@ -167,36 +166,38 @@ def list_mbeds(
 
         return result
 
-    def _fs_never(self, device, pn):
+    def _fs_never(self, device, filter_function):
         """Filter device without touching the file system of the device"""
         device['target_id'] = device['target_id_usb_id']
         device['target_id_mbed_htm'] = None
         device['platform_name'] = self.plat_db.get(device['target_id'][0:4])
-        if device['platform_name'] and not pn.match(device['platform_name']):
-            return None
-        else:
+        if not filter_function or filter_function(device):
             return device
+        else:
+            return None
 
-    def _fs_before_id_check(self, device, pn):
+    def _fs_before_id_check(self, device, filter_function):
         """Filter device after touching the file system of the device.
         Said another way: Touch the file system before filtering
         """
         self._update_device_from_htm(device)
-        if device['platform_name'] and not pn.match(device['platform_name']):
-            return None
-        else:
+        if not filter_function or filter_function(device):
             return device
+        else:
+            return None
 
-    def _fs_after_id_check(self, device, pn):
+    def _fs_after_id_check(self, device, filter_function):
         """Filter device before touching the file system of the device.
         Said another way: Touch the file system after filtering
         """
-        plat_name = self.plat_db.get(device['target_id_usb_id'][0:4])
-        if plat_name and not pn.match(plat_name):
-            return None
-        else:
+        device['target_id'] = device['target_id_usb_id']
+        device['target_id_mbed_htm'] = None
+        device['platform_name'] = self.plat_db.get(device['target_id'][0:4])
+        if not filter_function or filter_function(device):
             self._update_device_from_htm(device)
             return device
+        else:
+            return None
 
     def _update_device_from_htm(self, device):
         """Set the 'target_id', 'target_id_mbed_htm', 'platform_name' and

test/mbedls_toolsbase.py

@@ -156,14 +156,19 @@ def test_fs_never(self):
             'serial_port': 'invalid_serial_port'
         }
         with patch("mbed_lstools.lstools_base.MbedLsToolsBase._update_device_from_htm") as _up_htm:
-            filter = re.compile("")
-            ret = self.base._fs_never(device, filter)
+            filter = None
+            ret = self.base._fs_never(deepcopy(device), filter)
             self.assertIsNotNone(ret)
             self.assertEqual(ret['target_id'], ret['target_id_usb_id'])
             _up_htm.assert_not_called()
 
-            filter_out = re.compile("NOT-K64F")
-            ret = self.base._fs_never(device, filter_out)
+            filter_in = lambda m: m['platform_name'] == 'K64F'
+            ret = self.base._fs_never(deepcopy(device), filter_in)
+            self.assertIsNotNone(ret)
+            _up_htm.assert_not_called()
+
+            filter_out = lambda m: m['platform_name'] != 'K64F'
+            ret = self.base._fs_never(deepcopy(device), filter_out)
             self.assertIsNone(ret)
             _up_htm.assert_not_called()
 
@@ -176,16 +181,24 @@ def test_fs_after(self):
         with patch("mbed_lstools.lstools_base.MbedLsToolsBase._read_htm_ids") as _read_htm:
             new_device_id = "00017531642046"
             _read_htm.return_value = (new_device_id, {})
-            filter = re.compile("")
-            ret = self.base._fs_after_id_check(device, filter)
+            filter = None
+            ret = self.base._fs_after_id_check(deepcopy(device), filter)
             self.assertIsNotNone(ret)
             self.assertEqual(ret['target_id'], new_device_id)
             _read_htm.assert_called_with(device['mount_point'])
 
             _read_htm.reset_mock()
 
-            filter_out = re.compile("NOT-K64F")
-            ret = self.base._fs_after_id_check(device, filter_out)
+            filter_in = lambda m: m['target_id'] == device['target_id_usb_id']
+            ret = self.base._fs_after_id_check(deepcopy(device), filter_in)
+            self.assertIsNotNone(ret)
+            self.assertEqual(ret['target_id'], new_device_id)
+            _read_htm.assert_called_with(device['mount_point'])
+
+            _read_htm.reset_mock()
+
+            filter_out = lambda m: m['target_id'] == new_device_id
+            ret = self.base._fs_after_id_check(deepcopy(device), filter_out)
             self.assertIsNone(ret)
             _read_htm.assert_not_called()
 
@@ -198,16 +211,24 @@ def test_fs_before(self):
         with patch("mbed_lstools.lstools_base.MbedLsToolsBase._read_htm_ids") as _read_htm:
             new_device_id = u'00017575430420'
             _read_htm.return_value = (new_device_id, {})
-            filter = re.compile(u'')
-            ret = self.base._fs_before_id_check(device, filter)
+            filter = None
+            ret = self.base._fs_before_id_check(deepcopy(device), filter)
+            self.assertIsNotNone(ret)
+            self.assertEqual(ret['target_id'], new_device_id)
+            _read_htm.assert_called_with(device['mount_point'])
+
+            _read_htm.reset_mock()
+
+            filter_in = lambda m: m['target_id'] == '00017575430420'
+            ret = self.base._fs_before_id_check(deepcopy(device), filter_in)
             self.assertIsNotNone(ret)
             self.assertEqual(ret['target_id'], new_device_id)
             _read_htm.assert_called_with(device['mount_point'])
 
             _read_htm.reset_mock()
 
-            filter_out = re.compile("NOT-LPC2368")
-            ret = self.base._fs_before_id_check(device, filter_out)
+            filter_out = lambda m: m['target_id'] == '024075309420ABCE'
+            ret = self.base._fs_before_id_check(deepcopy(device), filter_out)
             self.assertIsNone(ret)
             _read_htm.assert_called_with(device['mount_point'])