Moved more text functions to text module (#2983)

src/molecule/command/base.py

@@ -30,7 +30,7 @@
 from click_help_colors import HelpColorsCommand, HelpColorsGroup
 
 import molecule.scenarios
-from molecule import config, logger, util
+from molecule import config, logger, text, util
 from molecule.console import should_do_markup
 
 LOG = logger.get_logger(__name__)
@@ -46,7 +46,7 @@ def wrapper(*args, **kwargs):
         LOG.info(
             "[info]Running [scenario]%s[/] > [action]%s[/][/]",
             self._config.scenario.name,
-            util.underscore(self.__class__.__name__),
+            text.underscore(self.__class__.__name__),
             extra={"markup": True},
         )
         rt = func(*args, **kwargs)
@@ -150,7 +150,7 @@ def execute_cmdline_scenarios(scenario_name, args, command_args, ansible_args=()
 def execute_subcommand(config, subcommand):
     """Execute subcommand."""
     command_module = getattr(molecule.command, subcommand)
-    command = getattr(command_module, util.camelize(subcommand))
+    command = getattr(command_module, text.camelize(subcommand))
     # knowledge of the current action is used by some provisioners
     # to ensure they behave correctly during certain sequence steps,
     # particulary the setting of ansible options in create/destroy,

src/molecule/command/list.py

@@ -26,7 +26,7 @@
 from rich.syntax import Syntax
 from rich.table import Table
 
-from molecule import logger, scenarios, util
+from molecule import logger, scenarios, text, util
 from molecule.command import base
 from molecule.console import console
 from molecule.status import Status
@@ -113,7 +113,7 @@ def list(ctx, scenario_name, format):  # pragma: no cover
     for scenario in s:
         statuses.extend(base.execute_subcommand(scenario.config, subcommand))
 
-    headers = [util.title(name) for name in Status._fields]
+    headers = [text.title(name) for name in Status._fields]
     if format == "simple" or format == "plain":
         table_format = format  # "simple"
 

src/molecule/test/unit/test_text.py

@@ -1,4 +1,22 @@
-from molecule.text import strip_ansi_color, strip_ansi_escape
+from molecule.text import (
+    camelize,
+    strip_ansi_color,
+    strip_ansi_escape,
+    title,
+    underscore,
+)
+
+
+def test_camelize():
+    assert "Foo" == camelize("foo")
+    assert "FooBar" == camelize("foo_bar")
+    assert "FooBarBaz" == camelize("foo_bar_baz")
+
+
+def test_strip_ansi_color():
+    s = "foo\x1b[0m\x1b[0m\x1b[0m\n\x1b[0m\x1b[0m\x1b[0m\x1b[0m\x1b[0m"
+
+    assert "foo\n" == strip_ansi_color(s)
 
 
 def test_strip_ansi_escape():
@@ -7,7 +25,12 @@ def test_strip_ansi_escape():
     assert "ls\r\nfoo\r\n" == strip_ansi_escape(string)
 
 
-def test_strip_ansi_color():
-    s = "foo\x1b[0m\x1b[0m\x1b[0m\n\x1b[0m\x1b[0m\x1b[0m\x1b[0m\x1b[0m"
+def test_title():
+    assert "Foo" == title("foo")
+    assert "Foo Bar" == title("foo_bar")
 
-    assert "foo\n" == strip_ansi_color(s)
+
+def test_underscore():
+    assert "foo" == underscore("Foo")
+    assert "foo_bar" == underscore("FooBar")
+    assert "foo_bar_baz" == underscore("FooBarBaz")

src/molecule/test/unit/test_util.py

@@ -265,11 +265,6 @@ def test_filter_verbose_permutation():
     assert x == util.filter_verbose_permutation(options)
 
 
-def test_title():
-    assert "Foo" == util.title("foo")
-    assert "Foo Bar" == util.title("foo_bar")
-
-
 def test_abs_path(temp_dir):
     x = os.path.abspath(os.path.join(os.getcwd(), os.path.pardir, "foo", "bar"))
 
@@ -280,18 +275,6 @@ def test_abs_path_with_none_path():
     assert util.abs_path(None) is None
 
 
-def test_camelize():
-    assert "Foo" == util.camelize("foo")
-    assert "FooBar" == util.camelize("foo_bar")
-    assert "FooBarBaz" == util.camelize("foo_bar_baz")
-
-
-def test_underscore():
-    assert "foo" == util.underscore("Foo")
-    assert "foo_bar" == util.underscore("FooBar")
-    assert "foo_bar_baz" == util.underscore("FooBarBaz")
-
-
 @pytest.mark.parametrize(
     "a,b,x",
     [

src/molecule/text.py

@@ -2,6 +2,13 @@
 import re
 
 
+def camelize(string):
+    """Format string as camel-case."""
+    # NOTE(retr0h): Taken from jpvanhal/inflection
+    # https://github.com/jpvanhal/inflection
+    return re.sub(r"(?:^|_)(.)", lambda m: m.group(1).upper(), string)
+
+
 def chomp(text: str) -> str:
     """Remove any training spaces from string."""
     return "\n".join([x.rstrip() for x in text.splitlines()])
@@ -28,3 +35,19 @@ def strip_ansi_color(data):
     invisible_codes = re.compile(r"\x1b\[\d*m")
 
     return re.sub(invisible_codes, "", data)
+
+
+def underscore(string):
+    """Format string to underlined notation."""
+    # NOTE(retr0h): Taken from jpvanhal/inflection
+    # https://github.com/jpvanhal/inflection
+    string = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", string)
+    string = re.sub(r"([a-z\d])([A-Z])", r"\1_\2", string)
+    string = string.replace("-", "_")
+
+    return string.lower()
+
+
+def title(word: str) -> str:
+    """Format title."""
+    return " ".join(x.capitalize() or "_" for x in word.split("_"))

src/molecule/util.py

@@ -272,35 +272,12 @@ def filter_verbose_permutation(options):
     return {k: options[k] for k in options if not re.match("^[v]+$", k)}
 
 
-def title(word):
-    """Format title."""
-    return " ".join(x.capitalize() or "_" for x in word.split("_"))
-
-
 def abs_path(path):
     """Return absolute path."""
     if path:
         return os.path.abspath(path)
 
 
-def camelize(string):
-    """Format string as camel-case."""
-    # NOTE(retr0h): Taken from jpvanhal/inflection
-    # https://github.com/jpvanhal/inflection
-    return re.sub(r"(?:^|_)(.)", lambda m: m.group(1).upper(), string)
-
-
-def underscore(string):
-    """Format string to underlined notation."""
-    # NOTE(retr0h): Taken from jpvanhal/inflection
-    # https://github.com/jpvanhal/inflection
-    string = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", string)
-    string = re.sub(r"([a-z\d])([A-Z])", r"\1_\2", string)
-    string = string.replace("-", "_")
-
-    return string.lower()
-
-
 def merge_dicts(a, b):
     """
     Merge the values of b into a and returns a new dict.