gibson-cli 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

gibson/command/Module.py

@@ -3,6 +3,7 @@ import sys
 
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import command, hint, input, subcommand
 
 
 class Module(BaseCommand):
@@ -10,8 +11,9 @@ class Module(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
+        self.configuration.ensure_project()
         if not re.search("^[a-z0-9]+$", sys.argv[2]):
-            self.conversation.display_project(self.configuration.project.name)
+            self.configuration.display_project()
             self.conversation.type("[module name] should only contain ^[a-z0-9]+$.\n\n")
             return True
 
@@ -30,12 +32,9 @@ class Module(BaseCommand):
             self.conversation.newline()
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} module [module name]\n"
-            + "  where [module name] is the name of the module I should create for "
-            + "this project\n"
-            + "  [module name] ~ ^[a-z0-9]+$\n"
+            f"usage: {command(self.configuration.command)} {subcommand('module')} {input('[module name]')} {hint('create a new module for this project')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/New.py

@@ -1,9 +1,8 @@
-import os
-import re
 import sys
 
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import argument, command, hint, subcommand
 
 
 class New(BaseCommand):
@@ -28,10 +27,9 @@ class New(BaseCommand):
         self.conversation.configure_new_project(self.configuration)
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} new [thing]\n"
-            + '  where [thing] can only be "project", for now\n'
+            f"usage: {command(self.configuration.command)} {subcommand('new')} {argument('project')} {hint('create a new project')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/OpenApi.py

@@ -4,11 +4,12 @@ import sys
 
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import command, hint, input, subcommand
 
 
 class OpenApi(BaseCommand):
     def bad_json(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
             "I need valid JSON. That file does not appear to be that. Try again?\n"
         )
@@ -30,7 +31,8 @@ class OpenApi(BaseCommand):
         if "paths" not in contents:
             self.unrecognized_format()
 
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.ensure_project()
+        self.configuration.display_project()
 
         if contents.get("info", None) is not None:
             if contents["info"].get("title", None) is not None:
@@ -115,7 +117,7 @@ class OpenApi(BaseCommand):
         return True
 
     def file_not_found(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
             f'Well that embarrassing. There is no file "{sys.argv[2]}".\n'
         )
@@ -123,7 +125,7 @@ class OpenApi(BaseCommand):
         exit(1)
 
     def unrecognized_format(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
             "Well that sucks. I do not recognize this JSON format.\n"
         )
@@ -131,10 +133,9 @@ class OpenApi(BaseCommand):
         exit(1)
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} openapi [file path]"
-            + "\n  where [file path] is the full path to an OpenAPI spec\n"
+            f"usage: {command(self.configuration.command)} {subcommand('openapi')} {input('[file path]')} {hint('import entities from an OpenAPI spec file')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Question.py

@@ -3,6 +3,7 @@ import sys
 
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import argument, command, hint, input, subcommand
 
 
 class Question(BaseCommand):
@@ -14,6 +15,7 @@ class Question(BaseCommand):
         if len(sys.argv) < 3:
             self.usage()
 
+        self.configuration.ensure_project()
         instructions = ""
         has_file = False
         has_python = False
@@ -80,25 +82,31 @@ class Question(BaseCommand):
         self.conversation.newline()
 
     def __file_not_found(self, path):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(f'404, My Friend. Cannot find file "{path}".\n')
         self.conversation.newline()
         exit(1)
 
     def __python_import_not_found(self, import_):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(f'That\'s a misfire, "{import_}" does not exist.\n')
         self.conversation.newline()
         exit(1)
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} ? [instructions]\n"
-            + "  where [instructions] is natural language\n"
-            + f"    use {self.TOKEN_FILE}[path] to import a file from the filesystem\n"
-            + f"    use {self.TOKEN_PYTHON}[import] to import a file from PYTHONPATH\n"
-            + f"    use {self.TOKEN_SQL}[entity name] to import the SQL\n"
+            f"usage: {command(self.configuration.command)} {subcommand('q')} {input('[instructions]')} {hint('ask a question or tell Gibson to do something using natural language')}\n"
         )
+        self.conversation.type(
+            f"    use {argument(self.TOKEN_FILE+'[path]')} to import a file from the filesystem\n"
+        )
+        self.conversation.type(
+            f"    use {argument(self.TOKEN_PYTHON+'[import]')} to import a file from PYTHONPATH\n"
+        )
+        self.conversation.type(
+            f"    use {argument(self.TOKEN_SQL+'[entity name]')} to import SQL\n"
+        )
+
         self.conversation.newline()
         exit(1)

gibson/command/Remove.py

@@ -3,6 +3,7 @@ import sys
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 from gibson.command.rewrite.Rewrite import Rewrite
+from gibson.core.Colors import command, hint, input, subcommand
 
 
 class Remove(BaseCommand):
@@ -10,7 +11,8 @@ class Remove(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.ensure_project()
+        self.configuration.display_project()
 
         found = False
 
@@ -70,10 +72,9 @@ class Remove(BaseCommand):
         return self
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} remove [entity name]\n"
-            + "  where [entity name] is one of the entities that exists in this project\n"
+            f"usage: {command(self.configuration.command)} {subcommand('remove')} {input('[entity name]')} {hint('remove an entity from the project')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Rename.py

@@ -3,6 +3,7 @@ import sys
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
 from gibson.command.rewrite.Rewrite import Rewrite
+from gibson.core.Colors import argument, command, hint, input, subcommand
 
 
 class Rename(BaseCommand):
@@ -10,7 +11,8 @@ class Rename(BaseCommand):
         if len(sys.argv) != 4:
             self.usage()
 
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.ensure_project()
+        self.configuration.display_project()
 
         if self.memory.recall_entity(sys.argv[2]) is None:
             self.conversation.type(
@@ -60,11 +62,9 @@ class Rename(BaseCommand):
         return self
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} rename [current] [new]\n"
-            + "  where [current] is the name of an entity and [new] is what "
-            + "you want to call it\n"
+            f"usage: {command(self.configuration.command)} {subcommand('rename')} {argument('[current]')} {input('[new]')} {hint('rename an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Schema.py

@@ -2,6 +2,7 @@ import sys
 
 from gibson.api.Cli import Cli
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import argument, command, hint, subcommand
 from gibson.core.TimeKeeper import TimeKeeper
 from gibson.dev.Dev import Dev
 
@@ -11,6 +12,7 @@ class Schema(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
+        self.configuration.ensure_project()
         entity = self.memory.recall_stored_entity(sys.argv[2])
         if entity is None:
             self.conversation.not_sure_no_entity(
@@ -31,11 +33,9 @@ class Schema(BaseCommand):
         time_keeper.display()
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} schema [entity name]\n"
-            + "  where [entity name] is one of the entities that exists in "
-            + "this project\n"
+            f"usage: {command(self.configuration.command)} {subcommand('schema')} {argument('[entity name]')} {hint('write the schema code for an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Show.py

@@ -1,16 +1,19 @@
 import sys
 
-from .BaseCommand import BaseCommand
+from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import argument, command, hint, subcommand
 
 
 class Show(BaseCommand):
     def execute(self):
         if len(sys.argv) == 2:
+            self.configuration.ensure_project()
             entities = self.memory.recall_merged()
             if entities is None:
                 self.conversation.cant_no_entities(self.configuration.project.name)
                 exit(1)
         elif len(sys.argv) == 3:
+            self.configuration.ensure_project()
             entity = self.memory.recall_entity(sys.argv[2])
             if entity is None:
                 self.conversation.not_sure_no_entity(
@@ -26,12 +29,12 @@ class Show(BaseCommand):
             print(entity["definition"])
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} show {{entity name}}\n"
-            + "  where {entity name} is one of the entities that exists in "
-            + "this project\n"
-            + "  omitting {entity name} displays all entities\n"
+            f"usage: {command(self.configuration.command)} {subcommand('show')} {hint('display the entire schema')}\n"
+        )
+        self.conversation.type(
+            f"   or: {command(self.configuration.command)} {subcommand('show')} {argument('[entity name]')} {hint('display the schema for an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Test.py

@@ -1,9 +1,10 @@
 import sys
 
 from gibson.api.Cli import Cli
-from gibson.dev.Dev import Dev
 from gibson.command.BaseCommand import BaseCommand
+from gibson.core.Colors import argument, command, hint, subcommand
 from gibson.core.TimeKeeper import TimeKeeper
+from gibson.dev.Dev import Dev
 
 
 class Test(BaseCommand):
@@ -11,6 +12,7 @@ class Test(BaseCommand):
         if len(sys.argv) != 3:
             self.usage()
 
+        self.configuration.ensure_project()
         entity = self.memory.recall_stored_entity(sys.argv[2])
         if entity is None:
             self.conversation.not_sure_no_entity(
@@ -31,11 +33,9 @@ class Test(BaseCommand):
         time_keeper.display()
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {self.configuration.command} test [entity name]\n"
-            + "  where [entity name] is one of the entities that exists "
-            + "in this project\n"
+            f"usage: {command(self.configuration.command)} {subcommand('test')} {argument('[entity name]')} {hint('write the unit tests for an entity')}\n"
         )
         self.conversation.newline()
         exit(1)

gibson/command/Tree.py

@@ -5,7 +5,8 @@ from .BaseCommand import BaseCommand
 
 class Tree(BaseCommand):
     def execute(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.ensure_project()
+        self.configuration.display_project()
 
         if self.configuration.project.dev.base.path is None:
             self.conversation.configure_dev_mode()

gibson/command/auth/Auth.py

@@ -18,9 +18,9 @@ class Auth(BaseCommand):
             self.usage()
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('auth')} {argument('login')} {hint('login to Gibson')} \n"
+            f"usage: {command(self.configuration.command)} {subcommand('auth')} {argument('login')} {hint('login to Gibson')}\n"
         )
         self.conversation.type(
             f"   or: {command(self.configuration.command)} {subcommand('auth')} {argument('logout')} {hint('logout of Gibson')}\n"

gibson/command/rewrite/Rewrite.py

@@ -37,12 +37,14 @@ class Rewrite(BaseCommand):
             self.usage()
 
     def write(self, argument=None):
+        self.configuration.ensure_project()
+
         if len(self.memory.recall_merged()) == 0:
             self.conversation.cant_no_entities(self.configuration.project.name)
             exit(1)
 
         if self.with_header is True:
-            self.conversation.display_project(self.configuration.project.name)
+            self.configuration.display_project()
 
         customization_manager = CustomizationManager(self.configuration).preserve()
 
@@ -113,9 +115,9 @@ class Rewrite(BaseCommand):
         return self
 
     def usage(self):
-        self.conversation.display_project(self.configuration.project.name)
+        self.configuration.display_project()
         self.conversation.type(
-            f"usage: {command(self.configuration.command)} {subcommand('rewrite')} {hint('rewrite all code')} \n"
+            f"usage: {command(self.configuration.command)} {subcommand('rewrite')} {hint('rewrite all code')}\n"
         )
         self.conversation.type(
             f"   or: {command(self.configuration.command)} {subcommand('rewrite')} {arguments(self.arguments)} {hint('rewrite only the specified code')}\n"

gibson/conf/Paths.py

@@ -1,6 +1,8 @@
 class ConfigPaths:
     def __init__(self):
         self.auth = None
+        self.config = None
+        self.top = None
 
 
 class ProjectPaths:

gibson/core/Colors.py

@@ -60,6 +60,10 @@ def arguments(list):
     return f"[{'|'.join(map(lambda x: argument(x), list))}]"
 
 
+def input(text):
+    return colorize(text, Color.WHITE2)
+
+
 def option(text):
     return colorize(text, Color.CYAN)
 

gibson/core/CommandRouter.py

@@ -7,6 +7,7 @@ from gibson.command.Conf import Conf
 from gibson.command.Count import Count
 from gibson.command.Dev import Dev
 from gibson.command.Forget import Forget
+from gibson.command.Help import Help
 from gibson.command.Import import Import
 from gibson.command.List import List
 from gibson.command.Merge import Merge
@@ -33,7 +34,6 @@ from gibson.command.WarGames import WarGames
 from gibson.core.Configuration import Configuration
 from gibson.core.Conversation import Conversation
 from gibson.core.Env import Env
-from gibson.core.Memory import Memory
 
 
 class CommandRouter:
@@ -41,127 +41,9 @@ class CommandRouter:
         self.configuration = configuration
         self.conversation = Conversation()
 
-    def help(self, exit_code=0):
-        dev_off = "*"
-        dev_on = ""
-        if self.configuration.project.dev.active is True:
-            dev_off = ""
-            dev_on = "*"
-
-        commands = {
-            "auth": {
-                "description": "login | logout",
-                "memory": None,
-            },
-            "build": {
-                "description": "create the entities in the datastore",
-                "memory": "stored",
-            },
-            "code": {"description": "pair program", "memory": None},
-            "conf": {"description": "set a configuration variable", "memory": None},
-            "count": {
-                "description": "show the number of entities stored",
-                "memory": "last | stored",
-            },
-            "dev": {
-                "description": f"mode off{dev_off} | on{dev_on}",
-                "memory": None,
-            },
-            "forget": {
-                "description": "delete memory",
-                "memory": "all | last | stored",
-            },
-            "help": {"description": "for help", "memory": None},
-            "import": {
-                "description": "configure from a data source",
-                "memory": "stored",
-            },
-            "list": {
-                "description": "show the names of entities in your project",
-                "memory": None,
-            },
-            "merge": {
-                "description": "move last changes into project",
-                "memory": "last -> stored",
-            },
-            "model": {
-                "description": "write the model code for an entity",
-                "memory": "stored",
-            },
-            "modify": {
-                "description": "change an entity using natural language",
-                "memory": "last > stored",
-            },
-            "module": {"description": "create a new module", "memory": "last"},
-            "new": {"description": "start something new", "memory": None},
-            "openapi": {"description": "build from an OpenAPI spec", "memory": "last"},
-            "remove": {
-                "description": "remove an entity from the project",
-                "memory": "last > stored",
-            },
-            "rename": {
-                "description": "rename an entity",
-                "memory": "last > stored",
-            },
-            "rewrite": {
-                "description": "rewrite code",
-                "memory": "stored",
-            },
-            "schema": {
-                "description": "write the schema code for an entity",
-                "memory": "stored",
-            },
-            "show": {"description": "display an entity", "memory": "last > stored"},
-            "test": {
-                "description": "write the unit tests for an entity",
-                "memory": "stored",
-            },
-            "tree": {"description": "illustrate the project layout", "memory": None},
-            "? | q": {"description": "ask a question", "memory": None},
-        }
-
-        self.conversation.set_delay(0.001)
-        self.conversation.display_project(self.configuration.project.name)
-        self.conversation.type(f"usage: {self.configuration.command} [command]\n\n")
-        self.conversation.type(" command  description" + " " * 40 + "memory\n")
-        self.conversation.type(" -------  -----------" + " " * 40 + "------\n")
-
-        for command, config in commands.items():
-            memory = ""
-            if config["memory"] is not None:
-                memory = f"[{config['memory']}]"
-
-            spaces = 61 - (8 + 2 + len(config["description"]))
-
-            self.conversation.type(
-                f"{command.rjust(8)}"
-                + f"  {config['description']}"
-                + " " * spaces
-                + f"{memory}\n"
-            )
-
-        self.conversation.newline()
-        self.conversation.type("memory:\n\n")
-
-        stats = Memory(self.configuration).stats()
-        self.conversation.type(
-            f"{str(stats['entities']['num']).rjust(8)}"
-            + f"  {stats['entities']['word']}"
-            + " " * (43 if stats["entities"]["word"] == "entities" else 45)
-            + "[stored]\n"
-        )
-        self.conversation.type(
-            f"{str(stats['last']['num']).rjust(8)}"
-            + f"  {stats['last']['word']}"
-            + " " * (43 if stats["last"]["word"] == "entities" else 45)
-            + "[last]\n\n"
-        )
-
-        exit(exit_code)
-
     def run(self):
-        if len(sys.argv) == 1 or sys.argv[1] == "help":
-            self.help()
+        if len(sys.argv) == 1:
+            Help(self.configuration).execute()
             return self
 
         Env().verify(self.configuration)
@@ -181,6 +63,8 @@ class CommandRouter:
             command = Dev(self.configuration)
         elif sys.argv[1] == "forget":
             command = Forget(self.configuration)
+        elif sys.argv[1] == "help":
+            command = Help(self.configuration)
         elif sys.argv[1] == "import":
             command = Import(self.configuration)
         elif sys.argv[1] == "list":
@@ -219,4 +103,5 @@ class CommandRouter:
             command = WarGames(self.configuration)
 
         if command is None or command.execute() is False:
-            self.help(exit_code=1)
+            Help(self.configuration).execute()
+            exit(1)