Add abbreviate method to StringUtils, More enhancements (#10)

* Add abbreviate method to StringUtils

* Fix code hygeine issues

* Fix code hygeine issues

Author: shashankrnr32

pycommons/lang/function/__init__.py

@@ -2,8 +2,8 @@
 
 from .consumer import Consumer, BiConsumer
 from .function import Function
-from .predicate import Predicate
+from .predicate import Predicate, BiPredicate
 from .runnable import Runnable
 from .supplier import Supplier
 
-__all__ = ["BiConsumer", "Consumer", "Function", "Predicate", "Runnable", "Supplier"]
+__all__ = ["BiConsumer", "Consumer", "Function", "Predicate", "Runnable", "Supplier", "BiPredicate"]

pycommons/lang/function/predicate.py

@@ -6,6 +6,7 @@
 from pycommons.lang.utils.objectutils import ObjectUtils
 
 _T = TypeVar("_T")
+_U = TypeVar("_U")
 
 
 class Predicate(Generic[_T]):
@@ -36,6 +37,34 @@ def __call__(self, t: _T, *args: Any, **kwargs: Any) -> bool:
         return self.test(t)
 
 
+class BiPredicate(Generic[_T, _U]):
+    @classmethod
+    def of(cls, predicate: Callable[[_T, _U], bool]) -> BiPredicate[_T, _U]:
+        ObjectUtils.require_not_none(predicate)
+
+        class BasicBiPredicate(BiPredicate[_T, _U]):
+            def test(self, t: _T, u: _U) -> bool:
+                return predicate(t, u)
+
+        return BasicBiPredicate()
+
+    @abstractmethod
+    def test(self, t: _T, u: _U) -> bool:
+        pass
+
+    def negate(self) -> BiPredicate[_T, _U]:
+        return self.of(lambda _t, _u: not self.test(_t, _u))
+
+    def do_and(self, predicate: BiPredicate[_T, _U]) -> BiPredicate[_T, _U]:
+        return self.of(lambda _t, _u: self.test(_t, _u) and predicate.test(_t, _u))
+
+    def do_or(self, predicate: BiPredicate[_T, _U]) -> BiPredicate[_T, _U]:
+        return self.of(lambda _t, _u: self.test(_t, _u) or predicate.test(_t, _u))
+
+    def __call__(self, t: _T, u: _U, *args: Any, **kwargs: Any) -> bool:
+        return self.test(t, u)
+
+
 class PassingPredicate(Predicate[_T]):
     def test(self, value: _T) -> bool:
         return True

pycommons/lang/utils/stringutils.py

@@ -22,6 +22,66 @@ class in the Apache Commons Lang package. Provides `None` safe methods to perfor
 
     EMPTY: str = ""
 
+    @classmethod
+    def abbreviate(
+        cls,
+        char_sequence: Optional[str],
+        abbrev_marker: Optional[str] = "...",
+        offset: int = 0,
+        max_width: int = -1,
+    ) -> Optional[str]:
+        if cls.is_not_empty(char_sequence) and cls.EMPTY == abbrev_marker and max_width > 0:
+            return typing.cast(str, char_sequence)[:max_width]
+
+        if cls.is_any_empty(char_sequence, abbrev_marker):
+            return char_sequence
+
+        char_sequence = typing.cast(str, abbrev_marker)
+        abbrev_marker = typing.cast(str, abbrev_marker)
+        abbrev_marker_length = len(abbrev_marker)
+        min_abbrev_width = abbrev_marker_length + 1
+        min_abbrev_width_offset = abbrev_marker_length + abbrev_marker_length + 1
+
+        if max_width == -1:
+            max_width = len(char_sequence) - abbrev_marker_length
+
+        if max_width < min_abbrev_width:
+            raise ValueError(f"Minimum abbreviation width is {min_abbrev_width}")
+
+        str_len = len(char_sequence)
+        if str_len <= max_width:
+            return char_sequence
+
+        offset = min(offset, str_len)
+
+        if str_len - offset < max_width - abbrev_marker_length:
+            offset = str_len - (max_width - abbrev_marker_length)
+
+        if offset <= abbrev_marker_length + 1:
+            return char_sequence[: max_width - abbrev_marker_length] + abbrev_marker
+
+        if max_width < min_abbrev_width_offset:
+            raise ValueError(f"Minimum abbreviation width with offset is {min_abbrev_width_offset}")
+        return char_sequence[offset : offset + max_width - abbrev_marker_length] + abbrev_marker
+
+    @classmethod
+    def abbreviate_middle(
+        cls, char_sequence: Optional[str], middle: Optional[str] = "...", length: int = 5
+    ) -> Optional[str]:
+        if (
+            not cls.is_any_empty(char_sequence, middle)
+            and len(typing.cast(str, char_sequence)) > length >= len(typing.cast(str, middle)) + 2
+        ):
+            middle = typing.cast(str, middle)
+            char_sequence = typing.cast(str, char_sequence)
+
+            target_string = length - len(middle)
+            start_offset = target_string // 2 + target_string % 2
+            end_offset = len(char_sequence) - target_string // 2
+            return char_sequence[:start_offset] + middle + char_sequence[end_offset:]
+
+        return char_sequence
+
     @classmethod
     def contains(cls, char_sequence: Optional[str], search_string: Optional[str]) -> bool:
         if char_sequence is not None and search_string is not None: