pax_global_header00006660000000000000000000000064144434243630014521gustar00rootroot0000000000000052 comment=57aae96649f5cf7fc98e50b1d62479456d492715 python-stringcase-1.2.0~git20230617.57aae96/000077500000000000000000000000001444342436300200115ustar00rootroot00000000000000python-stringcase-1.2.0~git20230617.57aae96/.coverage000066400000000000000000000007731444342436300216140ustar00rootroot00000000000000€}q(U collectorqUcoverage v3.7.1qUlinesq}q(U:/Users/okuni/projects/python-stringcase/stringcase_test.pyq]q(KKKKKK K KKKKKKKKKKKKKKK K"K#K%K&K(K*K+K,K-K.K/K0K1K3K4K6K8K9K:K "fooBarBaz" stringcase.camelcase('FooBarBaz') # => "fooBarBaz" stringcase.capitalcase('foo_bar_baz') # => "Foo_bar_baz" stringcase.capitalcase('FooBarBaz') # => "FooBarBaz" stringcase.constcase('foo_bar_baz') # => "FOO_BAR_BAZ" stringcase.constcase('FooBarBaz') # => "_FOO_BAR_BAZ" stringcase.lowercase('foo_bar_baz') # => "foo_bar_baz" stringcase.lowercase('FooBarBaz') # => "foobarbaz" stringcase.pascalcase('foo_bar_baz') # => "FooBarBaz" stringcase.pascalcase('FooBarBaz') # => "FooBarBaz" stringcase.pathcase('foo_bar_baz') # => "foo/bar/baz" stringcase.pathcase('FooBarBaz') # => "/foo/bar/baz" stringcase.sentencecase('foo_bar_baz') # => "Foo bar baz" stringcase.sentencecase('FooBarBaz') # => "Foo bar baz" stringcase.snakecase('foo_bar_baz') # => "foo_bar_baz" stringcase.snakecase('FooBarBaz') # => "foo_bar_baz" stringcase.spinalcase('foo_bar_baz') # => "foo-bar-baz" stringcase.spinalcase('FooBarBaz') # => "-foo-bar-baz" stringcase.titlecase('foo_bar_baz') # => "Foo Bar Baz" stringcase.titlecase('FooBarBaz') # => " Foo Bar Baz" stringcase.trimcase('foo_bar_baz') # => "foo_bar_baz" stringcase.trimcase('FooBarBaz') # => "FooBarBaz" stringcase.uppercase('foo_bar_baz') # => "FOO_BAR_BAZ" stringcase.uppercase('FooBarBaz') # => "FOOBARBAZ" stringcase.alphanumcase('_Foo., Bar') # =>'FooBar' stringcase.alphanumcase('Foo_123 Bar!') # =>'Foo123Bar' Install ------- :: $ pip install stringcase License ------- This software is released under the `MIT License `__. Author ------ - `Taka Okunishi `__ .. |build_status_badge| image:: http://img.shields.io/travis/okunishinishi/python-stringcase.svg?style=flat :target: http://travis-ci.org/okunishinishi/python-stringcase .. |coverage_badge| image:: http://img.shields.io/coveralls/apeman-repo/apeman-task-contrib-coz.svg?style=flat :target: https://coveralls.io/github/apeman-repo/apeman-task-contrib-coz .. |pypi_version_badge| image:: https://img.shields.io/pypi/v/stringcase.svg :target: https://pypi.python.org/pypi/stringcase python-stringcase-1.2.0~git20230617.57aae96/ci/000077500000000000000000000000001444342436300204045ustar00rootroot00000000000000python-stringcase-1.2.0~git20230617.57aae96/ci/release.sh000077500000000000000000000003011444342436300223550ustar00rootroot00000000000000#!/bin/bash HERE=$(cd "$(dirname $0)" && pwd) BASE_DIR=$(cd "${HERE}/.." && pwd) cd "${BASE_DIR}" python setup.py sdist twine upload dist/* git add . -A git commit -m 'Version up' git push python-stringcase-1.2.0~git20230617.57aae96/pyproject.toml000066400000000000000000000002241444342436300227230ustar00rootroot00000000000000[build-system] requires = ["setuptools>=44", "wheel", "setuptools_scm[toml]>=3.4.3"] build-backend = "setuptools.build_meta" [tool.setuptools_scm] python-stringcase-1.2.0~git20230617.57aae96/setup.cfg000066400000000000000000000004211444342436300216270ustar00rootroot00000000000000[metadata] name = stringcase author = Taka Okunishi author_email = okunishitaka.com@gmail.com license = MIT description = String case converter. url = https://github.com/okunishinishi/python-stringcase long_description = file: README.rst [options] py_modules = stringcase python-stringcase-1.2.0~git20230617.57aae96/setup.py000066400000000000000000000001051444342436300215170ustar00rootroot00000000000000from setuptools import setup if __name__ == "__main__": setup() python-stringcase-1.2.0~git20230617.57aae96/stringcase.py000066400000000000000000000111021444342436300225200ustar00rootroot00000000000000""" String convert functions """ import re def camelcase(string): """ Convert string into camel case. Args: string: String to convert. Returns: string: Camel case string. """ if string == "": return string string = string.replace("_","-") lst = string.split("-") for i in range(len(lst)): if i == 0: continue else: lst[i] = lst[i].capitalize() return "".join(lst) def capitalcase(string): """Convert string into capital case. First letters will be uppercase. Args: string: String to convert. Returns: string: Capital case string. """ string = str(string) if not string: return string return uppercase(string[0]) + string[1:] def constcase(string): """Convert string into upper snake case. Join punctuation with underscore and convert letters into uppercase. Args: string: String to convert. Returns: string: Const cased string. """ return uppercase(snakecase(string)) def lowercase(string): """Convert string into lower case. Args: string: String to convert. Returns: string: Lowercase case string. """ return str(string).lower() def pascalcase(string): """Convert string into pascal case. Args: string: String to convert. Returns: string: Pascal case string. """ return capitalcase(camelcase(string)) def pathcase(string): """Convert string into path case. Join punctuation with slash. Args: string: String to convert. Returns: string: Path cased string. """ string = snakecase(string) if not string: return string return re.sub(r"_", "/", string) def backslashcase(string): """Convert string into spinal case. Join punctuation with backslash. Args: string: String to convert. Returns: string: Spinal cased string. """ str1 = re.sub(r"_", r"\\", snakecase(string)) return str1 # return re.sub(r"\\n", "", str1)) # TODO: make regex fot \t ... def sentencecase(string): """Convert string into sentence case. First letter capped and each punctuations are joined with space. Args: string: String to convert. Returns: string: Sentence cased string. """ joiner = ' ' string = re.sub(r"[\-_\.\s]", joiner, str(string)) if not string: return string return capitalcase(trimcase( re.sub(r"[A-Z]", lambda matched: joiner + lowercase(matched.group(0)), string) )) def snakecase(string): """Convert string into snake case. Join punctuation with underscore Args: string: String to convert. Returns: string: Snake cased string. """ string = re.sub(r"[\-\.\s]", '_', str(string)) if not string: return string return lowercase(string[0]) + re.sub(r"[A-Z]", lambda matched: '_' + lowercase(matched.group(0)), string[1:]) def spinalcase(string): """Convert string into spinal case. Join punctuation with hyphen. Args: string: String to convert. Returns: string: Spinal cased string. """ return re.sub(r"_", "-", snakecase(string)) def dotcase(string): """Convert string into dot case. Join punctuation with dot. Args: string: String to convert. Returns: string: Dot cased string. """ return re.sub(r"_", ".", snakecase(string)) def titlecase(string): """Convert string into sentence case. First letter capped while each punctuations is capitalsed and joined with space. Args: string: String to convert. Returns: string: Title cased string. """ return ' '.join( [capitalcase(word) for word in snakecase(string).split("_")] ) def trimcase(string): """Convert string into trimmed string. Args: string: String to convert. Returns: string: Trimmed case string """ return str(string).strip() def uppercase(string): """Convert string into upper case. Args: string: String to convert. Returns: string: Uppercase case string. """ return str(string).upper() def alphanumcase(string): """Cuts all non-alphanumeric symbols, i.e. cuts all expect except 0-9, a-z and A-Z. Args: string: String to convert. Returns: string: String with cutted non-alphanumeric symbols. """ return ''.join(filter(str.isalnum, str(string))) python-stringcase-1.2.0~git20230617.57aae96/stringcase_test.py000077500000000000000000000112721444342436300235720ustar00rootroot00000000000000"""Unit test for stringcase """ from unittest import TestCase from os import path import sys sys.path.append(path.dirname(__file__)) import stringcase class StringcaseTest(TestCase): def test_camelcase(self): from stringcase import camelcase eq = self.assertEqual eq('fooBar', camelcase('foo_bar')) eq('fooBar', camelcase('FooBar')) eq('fooBar', camelcase('foo-bar')) eq('fooBar', camelcase('foo.bar')) eq('barBaz', camelcase('_bar_baz')) eq('barBaz', camelcase('.bar_baz')) eq('', camelcase('')) eq('none', camelcase(None)) def test_capitalcase(self): from stringcase import capitalcase eq = self.assertEqual eq('', capitalcase('')) eq('FooBar', capitalcase('fooBar')) def test_constcase(self): from stringcase import constcase eq = self.assertEqual eq('FOO_BAR', constcase('fooBar')) eq('FOO_BAR', constcase('foo_bar')) eq('FOO_BAR', constcase('foo-bar')) eq('FOO_BAR', constcase('foo.bar')) eq('_BAR_BAZ', constcase('_bar_baz')) eq('_BAR_BAZ', constcase('.bar_baz')) eq('', constcase('')) eq('NONE', constcase(None)) def test_lowercase(self): from stringcase import lowercase eq = self.assertEqual eq('none', lowercase(None)) eq('', lowercase('')) eq('foo', lowercase('Foo')) def test_pascalcase(self): from stringcase import pascalcase eq = self.assertEqual eq('FooBar', pascalcase('foo_bar')) eq('FooBar', pascalcase('foo-bar')) eq('FooBar', pascalcase('foo.bar')) eq('BarBaz', pascalcase('_bar_baz')) eq('BarBaz', pascalcase('.bar_baz')) eq('', pascalcase('')) eq('None', pascalcase(None)) def test_pathcase(self): from stringcase import pathcase eq = self.assertEqual eq('foo/bar', pathcase('fooBar')) eq('foo/bar', pathcase('foo_bar')) eq('foo/bar', pathcase('foo-bar')) eq('foo/bar', pathcase('foo.bar')) eq('/bar/baz', pathcase('_bar_baz')) eq('/bar/baz', pathcase('.bar_baz')) eq('', pathcase('')) eq('none', pathcase(None)) def test_sentencecase(self): from stringcase import sentencecase eq = self.assertEqual eq('Foo bar', sentencecase('fooBar')) eq('Foo bar', sentencecase('foo_bar')) eq('Foo bar', sentencecase('foo-bar')) eq('Foo bar', sentencecase('foo.bar')) eq('Bar baz', sentencecase('_bar_baz')) eq('Bar baz', sentencecase('.bar_baz')) eq('', sentencecase('')) eq('None', sentencecase(None)) def test_uppercase(self): from stringcase import uppercase eq = self.assertEqual eq('NONE', uppercase(None)) eq('', uppercase('')) eq('FOO', uppercase('foo')) def test_snakecase(self): from stringcase import snakecase eq = self.assertEqual eq('foo_bar', snakecase('fooBar')) eq('foo_bar', snakecase('foo_bar')) eq('foo_bar', snakecase('foo-bar')) eq('foo_bar', snakecase('foo.bar')) eq('_bar_baz', snakecase('_bar_baz')) eq('_bar_baz', snakecase('.bar_baz')) eq('', snakecase('')) eq('none', snakecase(None)) def test_spinalcase(self): from stringcase import spinalcase eq = self.assertEqual eq('foo-bar', spinalcase('fooBar')) eq('foo-bar', spinalcase('foo_bar')) eq('foo-bar', spinalcase('foo-bar')) eq('foo-bar', spinalcase('foo.bar')) eq('-bar-baz', spinalcase('_bar_baz')) eq('-bar-baz', spinalcase('.bar_baz')) eq('', spinalcase('')) eq('none', spinalcase(None)) def test_titlecase(self): from stringcase import titlecase eq = self.assertEqual eq('Foo Bar', titlecase('fooBar')) eq('Foo Bar', titlecase('foo_bar')) eq('Foo Bar', titlecase('foo-bar')) eq('Foo Bar', titlecase('foo.bar')) eq(' Bar Baz', titlecase('_bar_baz')) eq(' Bar Baz', titlecase('.bar_baz')) eq('', titlecase('')) eq('None', titlecase(None)) def test_trimcase(self): from stringcase import trimcase eq = self.assertEqual eq('foo bar baz', trimcase(' foo bar baz ')) eq('', trimcase('')) def test_alphanumcase(self): from stringcase import alphanumcase eq = self.assertEqual eq('FooBar', alphanumcase('_Foo., Bar')) eq('Foo123Bar', alphanumcase('Foo_123 Bar!')) eq('', alphanumcase('')) eq('None', alphanumcase(None)) if __name__ == '__main__': from unittest import main main()