gearbox 0.3.0__py3-none-any.whl

gearbox/command.py

@@ -0,0 +1,46 @@
+import argparse
+import inspect
+import os
+import sys
+
+from .template import GearBoxTemplate
+
+
+class Command(object):
+    deprecated = False
+
+    def __init__(self, app, app_args, cmd_name=None):
+        self.app = app
+        self.app_args = app_args
+        self.cmd_name = cmd_name
+
+    def get_description(self):
+        """Override to provide custom description for command."""
+        return inspect.getdoc(self.__class__) or ""
+
+    def get_parser(self, prog_name):
+        """Override to add command options."""
+        parser = argparse.ArgumentParser(
+            description=self.get_description(), prog=prog_name, add_help=False
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        """Override to do something useful."""
+        raise NotImplementedError
+
+    def run(self, parsed_args):
+        self.take_action(parsed_args)
+        return 0
+
+
+class TemplateCommand(Command):
+    template = GearBoxTemplate()
+
+    def get_template_path(self):
+        module = sys.modules[self.__class__.__module__]
+        module_path = module.__file__
+        return os.path.join(os.path.abspath(os.path.dirname(module_path)), "template")
+
+    def run_template(self, output_dir, opts):
+        self.template.run(self.get_template_path(), output_dir, vars(opts))

gearbox/commandmanager.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+"""Discover and lookup command plugins.
+
+This comes from OpenStack cliff.
+"""
+
+import importlib.metadata
+import logging
+
+LOG = logging.getLogger(__name__)
+
+
+class EntryPointWrapper(object):
+    """Wrap up a command class already imported to make it look like a plugin."""
+
+    def __init__(self, name, command_class):
+        self.name = name
+        self.command_class = command_class
+
+    def load(self, require=False):
+        return self.command_class
+
+
+class CommandManager(object):
+    """Discovers commands and handles lookup based on argv data.
+
+    :param namespace: String containing the setuptools entrypoint namespace
+                      for the plugins to be loaded. For example,
+                      ``'cliff.formatter.list'``.
+    :param convert_underscores: Whether cliff should convert underscores to
+                                spaces in entry_point commands.
+    """
+
+    def __init__(self, namespace, convert_underscores=True):
+        self.commands = {}
+        self.namespace = namespace
+        self.convert_underscores = convert_underscores
+        self._load_commands()
+
+    def _load_commands(self):
+        # NOTE(jamielennox): kept for compatability.
+        self.load_commands(self.namespace)
+
+    def load_commands(self, namespace):
+        """Load all the commands from an entrypoint"""
+        entry_points = importlib.metadata.entry_points()
+        if hasattr(entry_points, "select"):
+            entry_points = entry_points.select(group=namespace)
+        else:
+            entry_points = entry_points.get(namespace, [])
+        for ep in entry_points:
+            LOG.debug("found command %r", ep.name)
+            cmd_name = (
+                ep.name.replace("_", " ") if self.convert_underscores else ep.name
+            )
+            self.commands[cmd_name] = ep
+        return
+
+    def __iter__(self):
+        return iter(self.commands.items())
+
+    def add_command(self, name, command_class):
+        self.commands[name] = EntryPointWrapper(name, command_class)
+
+    def find_command(self, argv):
+        """Given an argument list, find a command and
+        return the processor and any remaining arguments.
+        """
+        search_args = argv[:]
+        name = ""
+        while search_args:
+            if search_args[0].startswith("-"):
+                name = "%s %s" % (name, search_args[0])
+                raise ValueError("Invalid command %r" % name)
+            next_val = search_args.pop(0)
+            name = "%s %s" % (name, next_val) if name else next_val
+            if name in self.commands:
+                cmd_ep = self.commands[name]
+                cmd_factory = cmd_ep.load()
+                return (cmd_factory, name, search_args)
+        else:
+            raise ValueError("Unknown command %r" % next(iter(argv), ""))

gearbox/commands/basic_package/__init__.py

@@ -0,0 +1,3 @@
+from .command import MakePackageCommand
+
+__all__ = ["MakePackageCommand"]

gearbox/commands/basic_package/command.py

@@ -0,0 +1,99 @@
+from __future__ import print_function
+
+import re
+
+from gearbox.command import TemplateCommand
+
+
+class MakePackageCommand(TemplateCommand):
+    CLEAN_PACKAGE_NAME_RE = re.compile("[^a-zA-Z0-9_]")
+
+    def get_description(self):
+        return "Creates a basic python package"
+
+    def get_parser(self, prog_name):
+        parser = super(MakePackageCommand, self).get_parser(prog_name)
+
+        parser.add_argument(
+            "-n",
+            "--name",
+            dest="project",
+            metavar="NAME",
+            required=True,
+            help="Project Name",
+        )
+
+        parser.add_argument(
+            "-o",
+            "--output-dir",
+            dest="output_dir",
+            metavar="OUTPUT_DIR",
+            help="Destination directory (by default the project name)",
+        )
+
+        parser.add_argument(
+            "-p",
+            "--package",
+            dest="package",
+            metavar="PACKAGE",
+            help="Python Package Name",
+        )
+
+        parser.add_argument(
+            "-a",
+            "--author",
+            dest="author",
+            metavar="AUTHOR",
+            default="Unknown",
+            help="Name of the package author",
+        )
+
+        parser.add_argument(
+            "-e",
+            "--email",
+            dest="author_email",
+            metavar="AUTHOR_EMAIL",
+            help="Email of the package author",
+        )
+
+        parser.add_argument(
+            "-u", "--url", dest="url", metavar="URL", help="Project homepage"
+        )
+
+        parser.add_argument(
+            "-l",
+            "--license",
+            dest="license_name",
+            metavar="LICENSE_NAME",
+            help="License used for the project",
+        )
+
+        parser.add_argument(
+            "-d",
+            "--description",
+            dest="description",
+            metavar="DESCRIPTION",
+            help="Package description",
+        )
+
+        parser.add_argument(
+            "-k",
+            "--keywords",
+            dest="keywords",
+            metavar="KEYWORDS",
+            help="Package keywords",
+        )
+
+        return parser
+
+    def take_action(self, opts):
+        if opts.package is None:
+            opts.package = self.CLEAN_PACKAGE_NAME_RE.sub("", opts.project.lower())
+
+        if opts.output_dir is None:
+            opts.output_dir = opts.project
+
+        opts.zip_safe = False
+        opts.version = "0.0.1"
+
+        self.run_template(opts.output_dir, opts)

gearbox/commands/basic_package/template/+package+/__init__.py

@@ -0,0 +1 @@
+#

gearbox/commands/basic_package/template/MANIFEST.in_tmpl

@@ -0,0 +1,2 @@
+global-exclude *.pyc
+

gearbox/commands/basic_package/template/README.rst_tmpl

@@ -0,0 +1,17 @@
+About {{package}}
+-------------------------
+
+{{package}} is a Python package created using the gearbox makepackage command.
+
+Installing
+-------------------------------
+
+{{package}} can be installed from pypi::
+
+    easy_install {{package}}
+
+or::
+
+    pip install {{package}}
+
+should just work for most of the users

gearbox/commands/basic_package/template/setup.py_tmpl

@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+import sys, os
+
+here = os.path.abspath(os.path.dirname(__file__))
+try:
+    README = open(os.path.join(here, 'README.rst')).read()
+except IOError:
+    README = ''
+
+version = "{{version}}"
+
+setup(name={{repr(project)}},
+      version=version,
+      description="{{description or ''}}",
+      long_description=README,
+      classifiers=[], # Get strings from http://pypi.python.org/pypi?%3Aaction=list_classifiers
+      keywords={{repr(keywords or '')}},
+      author={{repr(author or '')}},
+      author_email={{repr(author_email or '')}},
+      url={{repr(url or '')}},
+      license={{repr(license_name or '')}},
+      packages=find_packages(exclude=['ez_setup', 'examples', 'tests']),
+      include_package_data=True,
+      zip_safe=False,
+      install_requires=[
+          # -*- Extra requirements: -*-
+      ],
+      entry_points="""
+      # -*- Entry points: -*-
+      """,
+      )

gearbox/commands/help.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+
+import argparse
+import sys
+import traceback
+
+from ..command import Command
+
+
+class HelpAction(argparse.Action):
+    """Provide a custom action so the -h and --help options
+    to the main app will print a list of the commands.
+    The commands are determined by checking the CommandManager
+    instance, passed in as the "default" value for the action.
+    """
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        app = self.default
+        parser.print_help(sys.stdout)
+        print("\nCommands:")
+        command_manager = app.command_manager
+        for name, ep in sorted(command_manager):
+            try:
+                factory = ep.load()
+            except Exception:
+                print("Could not load %r" % ep)
+                if namespace.debug:
+                    traceback.print_exc(file=sys.stdout)
+                continue
+            try:
+                cmd = factory(app, None)
+                if cmd.deprecated:
+                    continue
+            except Exception as err:
+                print("Could not instantiate %r: %s\n" % (ep, err))
+                if namespace.debug:
+                    traceback.print_exc(file=sys.stdout)
+                continue
+            one_liner = cmd.get_description().split("\n")[0]
+            print("  %-13s  %s" % (name, one_liner))
+        sys.exit(0)
+
+
+class HelpCommand(Command):
+    """print detailed help for another command"""
+
+    def get_parser(self, prog_name):
+        parser = super(HelpCommand, self).get_parser(prog_name)
+        parser.add_argument(
+            "cmd",
+            nargs="*",
+            help="name of the command",
+        )
+        return parser
+
+    def take_action(self, parsed_args):
+        if not parsed_args.cmd:
+            action = HelpAction(None, None, default=self.app)
+            action(self.app.parser, self.app.parser, None, None)
+            return 1
+
+        try:
+            the_cmd = self.app.command_manager.find_command(
+                parsed_args.cmd,
+            )
+            cmd_factory, cmd_name, search_args = the_cmd
+        except ValueError:
+            # Did not find an exact match
+            cmd = parsed_args.cmd[0]
+            fuzzy_matches = [
+                k[0] for k in self.app.command_manager if k[0].startswith(cmd)
+            ]
+            if not fuzzy_matches:
+                raise
+            print('Command "%s" matches:' % cmd)
+            for fm in sorted(fuzzy_matches):
+                print("  %s" % fm)
+            return
+
+        self.app_args.cmd = search_args
+        cmd = cmd_factory(self.app, self.app_args)
+        full_name = " ".join([self.app.NAME, cmd_name])
+        cmd_parser = cmd.get_parser(full_name)
+        cmd_parser.print_help(sys.stdout)
+        return 0

gearbox/commands/patch.py

@@ -0,0 +1,160 @@
+from __future__ import print_function
+
+import fnmatch
+import os
+import re
+from argparse import RawDescriptionHelpFormatter
+
+from gearbox.command import Command
+
+
+class PatchCommand(Command):
+    def get_description(self):
+        return r"""Patches files by replacing, appending or deleting text.
+
+This is meant to provide a quick and easy way to replace text and
+code in your projects.
+
+Here are a few examples, this will replace all xi:include occurrences
+with py:extends in all the template files recursively:
+
+    $ gearbox patch -R '*.html' xi:include -r py:extends
+
+It is also possible to rely on regex and python for more complex
+replacements, like updating the Copyright year in your documentation:
+
+    $ gearbox patch -R '*.rst' -x 'Copyright(\s*)(\d+)' -e -r '"Copyright\\g<1>"+__import__("datetime").datetime.utcnow().strftime("%Y")'
+
+Works on a line by line basis, so it is not possible to match text
+across multiple lines.
+"""
+
+    def get_parser(self, prog_name):
+        parser = super(PatchCommand, self).get_parser(prog_name)
+        parser.formatter_class = RawDescriptionHelpFormatter
+
+        parser.add_argument(
+            "pattern", help="The glob pattern of files that should be matched"
+        )
+
+        parser.add_argument(
+            "text", help="text that should be looked up in matched files."
+        )
+
+        parser.add_argument(
+            "-r",
+            "--replace",
+            dest="replacement",
+            help="Replace occurrences of text with REPLACEMENT",
+        )
+
+        parser.add_argument(
+            "-a",
+            "--append",
+            dest="addition",
+            help="Append ADDITION after the line with matching text.",
+        )
+
+        parser.add_argument(
+            "-d", "--delete", action="store_true", help="Delete lines matching text."
+        )
+
+        parser.add_argument(
+            "-x",
+            "--regex",
+            dest="regex",
+            action="store_true",
+            help="Parse the text as a regular expression.",
+        )
+
+        parser.add_argument(
+            "-R",
+            "--recursive",
+            dest="recursive",
+            action="store_true",
+            help="Look for files matching pattern in subfolders too.",
+        )
+
+        parser.add_argument(
+            "-e",
+            "--eval",
+            dest="eval",
+            action="store_true",
+            help="Eval the replacement as Python code before applying it.",
+        )
+
+        return parser
+
+    def _walk_recursive(self):
+        for root, dirnames, filenames in os.walk(os.getcwd()):
+            for filename in filenames:
+                yield os.path.join(root, filename)
+
+    def _walk_flat(self):
+        root = os.getcwd()
+        for filename in os.listdir(root):
+            yield os.path.join(root, filename)
+
+    def _replace_regex(self, line, text, replacement):
+        return re.sub(text, replacement, line)
+
+    def _replace_plain(self, line, text, replacement):
+        return line.replace(text, replacement)
+
+    def _match_regex(self, line, text):
+        return re.search(text, line) is not None
+
+    def _match_plain(self, line, text):
+        return text in line
+
+    def take_action(self, opts):
+        walk = self._walk_flat
+        if opts.recursive:
+            walk = self._walk_recursive
+
+        match = self._match_plain
+        if opts.regex:
+            match = self._match_regex
+
+        replace = self._replace_plain
+        if opts.regex:
+            replace = self._replace_regex
+
+        matches = []
+        for filepath in walk():
+            if fnmatch.fnmatch(filepath, opts.pattern):
+                matches.append(filepath)
+
+        print("%s files matching" % len(matches))
+        for filepath in matches:
+            replacement = opts.replacement
+            if opts.eval and replacement:
+                replacement = str(eval(replacement, globals()))
+
+            addition = opts.addition
+            if opts.eval and addition:
+                addition = str(eval(addition, globals()))
+
+            matches = False
+            lines = []
+            with open(filepath) as f:
+                for line in f:
+                    if not match(line, opts.text):
+                        lines.append(line)
+                        continue
+
+                    matches = True
+                    empty_line = not line.strip()
+                    if opts.replacement:
+                        line = replace(line, opts.text, replacement)
+
+                    if empty_line or line.strip() and not opts.delete:
+                        lines.append(line)
+
+                    if opts.addition:
+                        lines.append(addition + "\n")
+
+            print("%s Patching %s" % (matches and "!" or "x", filepath))
+            if matches:
+                with open(filepath, "w") as f:
+                    f.writelines(lines)