--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/frontends/src/jp/cmd_shell.py	Thu Jul 06 20:28:25 2017 +0200
@@ -0,0 +1,259 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+
+# jp: a SàT command line tool
+# Copyright (C) 2009-2016 Jérôme Poisson (goffi@goffi.org)
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import base
+import cmd
+from sat.core.i18n import _
+from sat.core import exceptions
+from sat_frontends.jp.constants import Const as C
+from sat.tools.common.ansi import ANSI as A
+import shlex
+
+__commands__ = ["Shell"]
+INTRO = _(u"""Welcome to {app_name} shell, the Salut à Toi shell !
+
+This enrironment helps you using several {app_name} commands with similar parameters.
+
+To quit, just enter "quit" or press C-c.
+Enter "help" or "?" to know what to do
+""").format(app_name = C.APP_NAME)
+
+
+class Shell(base.CommandBase, cmd.Cmd):
+
+    def __init__(self, host):
+        base.CommandBase.__init__(self, host, 'shell', help=_(u'launch jp in shell (REPL) mode'))
+        cmd.Cmd.__init__(self)
+
+    def parse_args(self, args):
+        """parse line arguments"""
+        return shlex.split(args, posix=True)
+
+    def get_cmd_choices(self, cmd=None, parser=None):
+        if parser is None:
+            parser = self._cur_parser
+        try:
+            choices = parser._subparsers._group_actions[0].choices
+            return choices[cmd] if cmd is not None else choices
+        except (KeyError, AttributeError):
+            raise exceptions.NotFound
+
+    def update_path(self):
+        self._cur_parser = self.host.parser
+        self.help = u''
+        for idx, path_elt in enumerate(self.path):
+            try:
+                self._cur_parser = self.get_cmd_choices(path_elt)
+            except exceptions.NotFound:
+                self.disp(_(u'bad command path'), error=True)
+                self.path=self.path[:idx]
+                break
+            else:
+                self.help = self._cur_parser
+
+        self.prompt = A.color(C.A_PROMPT_PATH, u'/'.join(self.path)) + A.color(C.A_PROMPT_SUF, u'> ')
+        try:
+            self.actions = self.get_cmd_choices().keys()
+        except exceptions.NotFound:
+            self.actions = []
+
+    def add_parser_options(self):
+        pass
+
+    def escape_arg(self, arg):
+        """format arg with quotes"""
+        return u'"' + arg.replace(u'"',u'\\"') + u'"'
+
+    def format_args(self, args):
+        """format argument to be printed with quotes if needed"""
+        for arg in args:
+            if " " in arg:
+                yield self.escape_arg(arg)
+            else:
+                yield arg
+
+    def get_use_args(self, args):
+        """format args for current parser according to self.use"""
+        parser = self._cur_parser
+
+        # we check not optional args to see if there
+        # is a corresonding parser
+        # else USE args would not work correctly (only for current parser)
+        cmd_args = []
+        for arg in args:
+            if arg.startswith(u'-'):
+                break
+            try:
+                parser = self.get_cmd_choices(arg, parser)
+            except exceptions.NotFound:
+                break
+            cmd_args.append(arg)
+
+        # we remove command args
+        # they'll be in returned list (use_args)
+        del args[:len(cmd_args)]
+
+        opt_args = []
+        pos_args = []
+        actions = {a.dest: a for a in parser._actions}
+        for arg, value in self.use.iteritems():
+            try:
+                action = actions[arg]
+            except KeyError:
+                if self.verbose:
+                    self.disp(_(u'ignoring {name}={value}, not corresponding to any argument (in USE)').format(
+                        name=arg,
+                        value=self.escape_arg(value)))
+            else:
+                if self.verbose:
+                    self.disp(_(u'arg {name}={value} set (in USE)').format(name=arg, value=self.escape_arg(value)))
+                if not action.option_strings:
+                    pos_args.append(value)
+                else:
+                    opt_args.append(action.option_strings[0])
+                    opt_args.append(value)
+        return cmd_args + opt_args + pos_args
+
+    def default(self, args):
+        """called when no shell command is recognized
+
+        will launch the command with args on the line
+        (i.e. will launch do [args])
+        """
+        self.do_do(args)
+
+    def do_help(self, args):
+        """show help message"""
+        self.disp(A.color(C.A_HEADER, _(u'Shell commands:')), no_lf=True)
+        super(Shell, self).do_help(args)
+        if not args:
+            self.disp(A.color(C.A_HEADER, _(u'Action commands:')))
+            help_list = self._cur_parser.format_help().split('\n\n')
+            print('\n\n'.join(help_list[1 if self.path else 2:]))
+
+    def do_debug(self, args):
+        """launch internal debugger"""
+        try:
+            import ipdb as pdb
+        except ImportError:
+            import pdb
+        pdb.set_trace()
+
+    def do_verbose(self, args):
+        """show verbose mode, or (de)activate it"""
+        args = self.parse_args(args)
+        if args:
+            self.verbose = C.bool(args[0])
+        self.disp(_(u'verbose mode is {status}').format(
+            status = _(u'ENABLED') if self.verbose else _(u'DISABLED')))
+
+    def do_cmd(self, args):
+        """change command path"""
+        if args == '..':
+            self.path = self.path[:-1]
+        else:
+            if not args or args[0] == '/':
+                self.path = []
+            args = '/'.join(args.split())
+            for path_elt in args.split('/'):
+                path_elt = path_elt.strip()
+                if not path_elt:
+                    continue
+                self.path.append(path_elt)
+        self.update_path()
+
+    def do_version(self, args):
+        """show current SàT/jp version"""
+        try:
+            self.host.run(['--version'])
+        except SystemExit:
+            pass
+
+    def do_do(self, args):
+        """lauch a command"""
+        # we don't want host to really exit
+        # we want to stay in the loop
+        self.host._no_exit = True
+        args = self.parse_args(args)
+        # args may be modified by use_args
+        # to remove subparsers from it
+        use_args = self.get_use_args(args)
+        cmd_args = self.path + use_args + args
+        if self.verbose:
+            self.disp(u"COMMAND => {args}".format(args=u' '.join(self.format_args(cmd_args))))
+        try:
+            self.host.run(cmd_args)
+        except SystemExit as e:
+            if e.code != 0:
+                self.disp(A.color(C.A_FAILURE, u'command failed with an error code of {err_no}'.format(err_no=e.code)), error=True)
+        except Exception as e:
+            self.disp(A.color(C.A_FAILURE, u'command failed with an exception: {msg}'.format(msg=e)), error=True)
+        finally:
+            self.host._no_exit = False
+
+    def do_use(self, args):
+        """fix an argument"""
+        args = self.parse_args(args)
+        if not args:
+            if not self.use:
+                self.disp(_(u'no argument in USE'))
+            else:
+                self.disp(_(u'arguments in USE:'))
+                for arg, value in self.use.iteritems():
+                    self.disp(_(A.color(C.A_SUBHEADER, arg, A.RESET, u' = ', self.escape_arg(value))))
+        elif len(args) != 2:
+            self.disp(u'bad syntax, please use:\nuse [arg] [value]', error=True)
+        else:
+            self.use[args[0]] = u' '.join(args[1:])
+            if self.verbose:
+                self.disp('set {name} = {value}'.format(
+                    name = args[0], value=self.escape_arg(args[1])))
+
+    def do_use_clear(self, args):
+        """unset one or many argument(s) in USE, or all of them if no arg is specified"""
+        args = self.parse_args(args)
+        if not args:
+            self.use.clear()
+        else:
+            for arg in args:
+                try:
+                    del self.use[arg]
+                except KeyError:
+                    self.disp(A.color(C.A_FAILURE, _(u'argument {name} not found').format(name=arg)), error=True)
+                else:
+                    if self.verbose:
+                        self.disp(_(u'argument {name} removed').format(name=arg))
+
+    def do_quit(self, args):
+        u"""quit the shell"""
+        self.disp(_(u'good bye!'))
+        self.host.quit()
+
+    def do_exit(self, args):
+        u"""alias for quit"""
+        self.do_quit(args)
+
+    def start(self):
+        self.path = []
+        self._cur_parser = self.host.parser
+        self.use = {}
+        self.verbose = False
+        self.update_path()
+        self.cmdloop(INTRO.encode('utf-8'))