crashbytes-strutils 1.0.0__tar.gz

crashbytes_strutils-1.0.0/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @CrashBytes

crashbytes_strutils-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,23 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[dev]"
+      - run: ruff check src/ tests/
+      - run: mypy --strict src/
+      - run: pytest --cov=crashbytes_strutils --cov-branch --cov-fail-under=90

crashbytes_strutils-1.0.0/.github/workflows/publish.yml

@@ -0,0 +1,19 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags: ["*"]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build
+      - run: python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

crashbytes_strutils-1.0.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+dist/
+build/
+*.egg-info/
+.coverage
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+

crashbytes_strutils-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CrashBytes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crashbytes_strutils-1.0.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: crashbytes-strutils
+Version: 1.0.0
+Summary: Zero-dependency string utilities — case conversion, slugify, masking, and more.
+Project-URL: Homepage, https://github.com/CrashBytes/crashbytes-strutils
+Project-URL: Repository, https://github.com/CrashBytes/crashbytes-strutils
+Project-URL: Issues, https://github.com/CrashBytes/crashbytes-strutils/issues
+Author-email: CrashBytes <crashbytes@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: case-conversion,slugify,string,text,utilities
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# crashbytes-strutils
+
+Zero-dependency string utilities — case conversion, slugify, masking, and more.
+
+## Install
+
+```bash
+pip install crashbytes-strutils
+```
+
+## Usage
+
+```python
+from crashbytes_strutils import to_snake_case, slugify, mask, truncate
+
+to_snake_case("helloWorld")      # "hello_world"
+slugify("Hello World!")          # "hello-world"
+mask("4111111111111111")         # "************1111"
+truncate("Long text here", 10)  # "Long te..."
+```
+
+## API
+
+### Case Conversion
+`to_snake_case`, `to_camel_case`, `to_pascal_case`, `to_kebab_case`, `to_title_case`, `to_constant_case`
+
+### Text Manipulation
+`slugify`, `truncate`, `mask`, `between`, `strip_html`, `reverse`, `pad_left`, `pad_right`, `remove_whitespace`
+
+### Validation
+`is_valid_email`, `is_blank`
+
+### Analysis
+`count_words`, `initials`
+
+## License
+
+MIT

crashbytes_strutils-1.0.0/README.md

@@ -0,0 +1,38 @@
+# crashbytes-strutils
+
+Zero-dependency string utilities — case conversion, slugify, masking, and more.
+
+## Install
+
+```bash
+pip install crashbytes-strutils
+```
+
+## Usage
+
+```python
+from crashbytes_strutils import to_snake_case, slugify, mask, truncate
+
+to_snake_case("helloWorld")      # "hello_world"
+slugify("Hello World!")          # "hello-world"
+mask("4111111111111111")         # "************1111"
+truncate("Long text here", 10)  # "Long te..."
+```
+
+## API
+
+### Case Conversion
+`to_snake_case`, `to_camel_case`, `to_pascal_case`, `to_kebab_case`, `to_title_case`, `to_constant_case`
+
+### Text Manipulation
+`slugify`, `truncate`, `mask`, `between`, `strip_html`, `reverse`, `pad_left`, `pad_right`, `remove_whitespace`
+
+### Validation
+`is_valid_email`, `is_blank`
+
+### Analysis
+`count_words`, `initials`
+
+## License
+
+MIT

crashbytes_strutils-1.0.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "crashbytes-strutils"
+version = "1.0.0"
+description = "Zero-dependency string utilities — case conversion, slugify, masking, and more."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "CrashBytes", email = "crashbytes@users.noreply.github.com" }]
+keywords = ["string", "utilities", "slugify", "case-conversion", "text"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "pytest-cov", "mypy", "ruff"]
+
+[project.urls]
+Homepage = "https://github.com/CrashBytes/crashbytes-strutils"
+Repository = "https://github.com/CrashBytes/crashbytes-strutils"
+Issues = "https://github.com/CrashBytes/crashbytes-strutils/issues"
+
+[tool.ruff]
+target-version = "py310"
+line-length = 99
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B", "SIM", "TCH"]
+
+[tool.mypy]
+strict = true
+python_version = "3.10"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.coverage.run]
+branch = true
+source = ["crashbytes_strutils"]
+
+[tool.coverage.report]
+fail_under = 90

crashbytes_strutils-1.0.0/src/crashbytes_strutils/__init__.py

@@ -0,0 +1,45 @@
+"""crashbytes-strutils — Zero-dependency string utilities."""
+
+from crashbytes_strutils._core import (
+    between,
+    count_words,
+    initials,
+    is_blank,
+    is_valid_email,
+    mask,
+    pad_left,
+    pad_right,
+    remove_whitespace,
+    reverse,
+    slugify,
+    strip_html,
+    to_camel_case,
+    to_constant_case,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
+    to_title_case,
+    truncate,
+)
+
+__all__ = [
+    "between",
+    "count_words",
+    "initials",
+    "is_blank",
+    "is_valid_email",
+    "mask",
+    "pad_left",
+    "pad_right",
+    "remove_whitespace",
+    "reverse",
+    "slugify",
+    "strip_html",
+    "to_camel_case",
+    "to_constant_case",
+    "to_kebab_case",
+    "to_pascal_case",
+    "to_snake_case",
+    "to_title_case",
+    "truncate",
+]

crashbytes_strutils-1.0.0/src/crashbytes_strutils/_core.py

@@ -0,0 +1,128 @@
+"""String utilities — case conversion, slugify, masking, and more."""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+_EMAIL_RE = re.compile(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
+_WORD_BOUNDARY_RE = re.compile(r"[A-Z]+(?=[A-Z][a-z])|[A-Z]?[a-z]+|[A-Z]+|[0-9]+")
+_NON_ALPHANUM_RE = re.compile(r"[^a-z0-9]+")
+_HTML_TAG_RE = re.compile(r"<[^>]+>")
+
+
+def _split_words(text: str) -> list[str]:
+    """Split text into words at case boundaries, spaces, hyphens, underscores."""
+    return _WORD_BOUNDARY_RE.findall(text)
+
+
+def to_snake_case(text: str) -> str:
+    """Convert text to ``snake_case``."""
+    return "_".join(w.lower() for w in _split_words(text))
+
+
+def to_camel_case(text: str) -> str:
+    """Convert text to ``camelCase``."""
+    words = _split_words(text)
+    if not words:
+        return ""
+    return words[0].lower() + "".join(w.capitalize() for w in words[1:])
+
+
+def to_pascal_case(text: str) -> str:
+    """Convert text to ``PascalCase``."""
+    return "".join(w.capitalize() for w in _split_words(text))
+
+
+def to_kebab_case(text: str) -> str:
+    """Convert text to ``kebab-case``."""
+    return "-".join(w.lower() for w in _split_words(text))
+
+
+def to_title_case(text: str) -> str:
+    """Convert text to ``Title Case``."""
+    return " ".join(w.capitalize() for w in _split_words(text))
+
+
+def to_constant_case(text: str) -> str:
+    """Convert text to ``CONSTANT_CASE``."""
+    return "_".join(w.upper() for w in _split_words(text))
+
+
+def slugify(text: str) -> str:
+    """Convert text to a URL-friendly slug."""
+    normalized = unicodedata.normalize("NFKD", text)
+    ascii_text = normalized.encode("ascii", "ignore").decode("ascii").lower()
+    slug = _NON_ALPHANUM_RE.sub("-", ascii_text).strip("-")
+    return re.sub(r"-{2,}", "-", slug)
+
+
+def truncate(text: str, max_length: int, suffix: str = "...") -> str:
+    """Truncate *text* to *max_length* characters, appending *suffix* if cut."""
+    if len(text) <= max_length:
+        return text
+    return text[: max_length - len(suffix)] + suffix
+
+
+def mask(text: str, visible: int = 4, char: str = "*") -> str:
+    """Mask all but the last *visible* characters."""
+    if len(text) <= visible:
+        return text
+    return char * (len(text) - visible) + text[-visible:]
+
+
+def between(text: str, start: str, end: str) -> str | None:
+    """Extract the substring between *start* and *end*, or ``None``."""
+    s = text.find(start)
+    if s == -1:
+        return None
+    s += len(start)
+    e = text.find(end, s)
+    if e == -1:
+        return None
+    return text[s:e]
+
+
+def strip_html(text: str) -> str:
+    """Remove HTML tags from *text*."""
+    return _HTML_TAG_RE.sub("", text)
+
+
+def is_valid_email(value: str) -> bool:
+    """Check if *value* is a valid email address."""
+    return bool(_EMAIL_RE.match(value))
+
+
+def is_blank(value: str | None) -> bool:
+    """Check if *value* is ``None``, empty, or whitespace-only."""
+    return value is None or value.strip() == ""
+
+
+def reverse(text: str) -> str:
+    """Reverse a string."""
+    return text[::-1]
+
+
+def count_words(text: str) -> int:
+    """Count the number of words in *text*."""
+    return len(text.split())
+
+
+def initials(text: str, separator: str = "") -> str:
+    """Extract initials from *text*."""
+    return separator.join(w[0].upper() for w in text.split() if w)
+
+
+def pad_left(text: str, length: int, char: str = " ") -> str:
+    """Pad *text* on the left to *length* with *char*."""
+    return text.rjust(length, char)
+
+
+def pad_right(text: str, length: int, char: str = " ") -> str:
+    """Pad *text* on the right to *length* with *char*."""
+    return text.ljust(length, char)
+
+
+def remove_whitespace(text: str) -> str:
+    """Remove all whitespace from *text*."""
+    return re.sub(r"\s+", "", text)

crashbytes_strutils-1.0.0/tests/test_strutils.py

@@ -0,0 +1,173 @@
+"""Tests for crashbytes-strutils."""
+
+from __future__ import annotations
+
+from crashbytes_strutils import (
+    between,
+    count_words,
+    initials,
+    is_blank,
+    is_valid_email,
+    mask,
+    pad_left,
+    pad_right,
+    remove_whitespace,
+    reverse,
+    slugify,
+    strip_html,
+    to_camel_case,
+    to_constant_case,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
+    to_title_case,
+    truncate,
+)
+
+
+class TestCaseConversion:
+    def test_to_snake_case(self) -> None:
+        assert to_snake_case("helloWorld") == "hello_world"
+        assert to_snake_case("HelloWorld") == "hello_world"
+        assert to_snake_case("hello-world") == "hello_world"
+        assert to_snake_case("HELLO_WORLD") == "hello_world"
+        assert to_snake_case("XMLParser") == "xml_parser"
+
+    def test_to_camel_case(self) -> None:
+        assert to_camel_case("hello_world") == "helloWorld"
+        assert to_camel_case("HelloWorld") == "helloWorld"
+        assert to_camel_case("hello-world") == "helloWorld"
+        assert to_camel_case("") == ""
+
+    def test_to_pascal_case(self) -> None:
+        assert to_pascal_case("hello_world") == "HelloWorld"
+        assert to_pascal_case("helloWorld") == "HelloWorld"
+
+    def test_to_kebab_case(self) -> None:
+        assert to_kebab_case("helloWorld") == "hello-world"
+        assert to_kebab_case("hello_world") == "hello-world"
+
+    def test_to_title_case(self) -> None:
+        assert to_title_case("hello_world") == "Hello World"
+        assert to_title_case("helloWorld") == "Hello World"
+
+    def test_to_constant_case(self) -> None:
+        assert to_constant_case("helloWorld") == "HELLO_WORLD"
+        assert to_constant_case("hello-world") == "HELLO_WORLD"
+
+
+class TestSlugify:
+    def test_basic(self) -> None:
+        assert slugify("Hello World") == "hello-world"
+
+    def test_special_chars(self) -> None:
+        assert slugify("Hello & World!") == "hello-world"
+
+    def test_unicode(self) -> None:
+        assert slugify("H\u00e9llo W\u00f6rld") == "hello-world"
+
+    def test_multiple_dashes(self) -> None:
+        assert slugify("hello   world") == "hello-world"
+
+    def test_leading_trailing(self) -> None:
+        assert slugify("  hello  ") == "hello"
+
+
+class TestTruncate:
+    def test_no_truncation_needed(self) -> None:
+        assert truncate("hello", 10) == "hello"
+
+    def test_truncation(self) -> None:
+        assert truncate("hello world", 8) == "hello..."
+
+    def test_custom_suffix(self) -> None:
+        assert truncate("hello world", 8, "~") == "hello w~"
+
+    def test_exact_length(self) -> None:
+        assert truncate("hello", 5) == "hello"
+
+
+class TestMask:
+    def test_basic(self) -> None:
+        assert mask("1234567890") == "******7890"
+
+    def test_custom_visible(self) -> None:
+        assert mask("1234567890", visible=2) == "********90"
+
+    def test_custom_char(self) -> None:
+        assert mask("1234567890", char="#") == "######7890"
+
+    def test_short_string(self) -> None:
+        assert mask("123", visible=4) == "123"
+
+
+class TestBetween:
+    def test_basic(self) -> None:
+        assert between("Hello [World] End", "[", "]") == "World"
+
+    def test_no_start(self) -> None:
+        assert between("Hello World", "[", "]") is None
+
+    def test_no_end(self) -> None:
+        assert between("Hello [World", "[", "]") is None
+
+    def test_empty_result(self) -> None:
+        assert between("Hello [] End", "[", "]") == ""
+
+
+class TestStripHtml:
+    def test_basic(self) -> None:
+        assert strip_html("<p>Hello</p>") == "Hello"
+
+    def test_nested(self) -> None:
+        assert strip_html("<div><b>Hello</b></div>") == "Hello"
+
+    def test_no_tags(self) -> None:
+        assert strip_html("Hello") == "Hello"
+
+    def test_self_closing(self) -> None:
+        assert strip_html("Hello<br/>World") == "HelloWorld"
+
+
+class TestValidation:
+    def test_valid_email(self) -> None:
+        assert is_valid_email("user@example.com") is True
+
+    def test_invalid_email(self) -> None:
+        assert is_valid_email("not-an-email") is False
+
+    def test_is_blank_none(self) -> None:
+        assert is_blank(None) is True
+
+    def test_is_blank_empty(self) -> None:
+        assert is_blank("") is True
+
+    def test_is_blank_whitespace(self) -> None:
+        assert is_blank("   ") is True
+
+    def test_is_blank_content(self) -> None:
+        assert is_blank("hello") is False
+
+
+class TestMisc:
+    def test_reverse(self) -> None:
+        assert reverse("hello") == "olleh"
+        assert reverse("") == ""
+
+    def test_count_words(self) -> None:
+        assert count_words("hello world foo") == 3
+        assert count_words("") == 0
+
+    def test_initials(self) -> None:
+        assert initials("John Doe") == "JD"
+        assert initials("John Doe", separator=".") == "J.D"
+
+    def test_pad_left(self) -> None:
+        assert pad_left("42", 5, "0") == "00042"
+
+    def test_pad_right(self) -> None:
+        assert pad_right("hi", 5) == "hi   "
+
+    def test_remove_whitespace(self) -> None:
+        assert remove_whitespace("hello world") == "helloworld"
+        assert remove_whitespace("  a  b  ") == "ab"