path: root/js/codeq/python.js

/* CodeQ: an online programming tutor.
   Copyright (C) 2015 UL FRI

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/>. */

/**
 * Created by robert on 9/17/15.
 *
 * The python state of the state machine. When it is entered it'll prepare the console and code editor and load a sub-state machine which represents the 4 different parts fo the screen.
 *
 * Currentyl it is mostly a copy of the prolog state (the exception is of course the makePythonTerminalHandler instead of makePrologTerminalHandler)
 */

(function() {
    "use strict";
    var subScreens, //this will be the actual (sub)state machine
        stateNameTag = 'stateName', //a tag for data which is added to some html elements
        jqScreen = $('#screen_python'), // the screen container element
        //quadrants
        jqDescription = jqScreen.find('.block1'),
        jqCode = jqScreen.find('.block2'),
        jqConsole = jqScreen.find('.block3'),
        jqInfo = jqScreen.find('.block4'),
        jqAllQuadrants = jqDescription.add(jqCode).add(jqConsole).add(jqInfo), // all the quadrants
        // buttons
        jqBtnPlan = jqScreen.find('.btn-plan'),
        jqBtnHint = jqScreen.find('.btn-hint').ladda(),
        jqBtnTest = jqScreen.find('.btn-test').ladda(),
        jqBtnRun = jqScreen.find('.btn-run'),
        jqBtnStop = jqScreen.find('.btn-stop'),
        jqInfoButtons = jqBtnPlan.add(jqBtnHint).add(jqBtnTest), // all info-focusing buttons
        jqAllButtons = jqInfoButtons.add(jqBtnRun).add(jqBtnStop), // all buttons
        // misc
        currentSubState = null,
        transitionEventName = 'mousedown',//event name of the event which will trigger the transition between these substates - the most common transition at least (there are some corner cases on the hint and test buttons -> see the code below)
        substates = {
            'description': {
                'enter': function () {
                    currentSubState = 'block1';
                    jqScreen.addClass(currentSubState);
                },
                'exit': function () {
                    jqScreen.removeClass(currentSubState);
                    currentSubState = null;
                }
            },
            'code': {
                'enter': function () {
                    currentSubState = 'block2';
                    jqScreen.addClass(currentSubState);
                },
                'exit': function () {
                    jqScreen.removeClass(currentSubState);
                    currentSubState = null;
                }
            },
            'info': {
                'enter': function () {
                    currentSubState = 'block4';
                    jqScreen.addClass(currentSubState);
                },
                'exit': function () {
                    jqScreen.removeClass(currentSubState);
                    currentSubState = null;
                }
            },
            'console': {
                'enter': function () {
                    currentSubState = 'block3';
                    jqScreen.addClass(currentSubState);
                },
                'exit': function () {
                    jqScreen.removeClass(currentSubState);
                    currentSubState = null;
                }
            }
        };
    var pythonHandler; //created when we enter the python state and destroyed once we leave it

    var enterFun = function(problemDef, commonDef, currentSolution){
        $('#navigation-problem_list').css('display', '');
        var navigationPhython = $("#navigation-python");
        navigationPhython.addClass("active");
        navigationPhython.css('display', '');

        jqScreen.css('display', '');//we have to show the screen now so the code editor shows its initial values correctly
        pythonHandler = createPythonHandler(problemDef, commonDef, currentSolution);
        subScreens = codeq.makeStateMachine(substates);
        subScreens.transition(jqDescription.data(stateNameTag));

        jqInfoButtons.on(transitionEventName, function (event) {
            subScreens.transition('info'); // set focus on the hints quadrant
            event.stopPropagation(); // don't allow the event to go on and trigger further transition
        });
        jqBtnRun.on(transitionEventName, function (event) {
            subScreens.transition('console'); // set focus on the hints quadrant
            event.stopPropagation(); // don't allow the event to go on and trigger further transition
        });

        jqAllQuadrants.on(transitionEventName, function () {
            subScreens.transition($(this).data(stateNameTag));
        });
    };

    codeq.globalStateMachine.register('python', {
        'jqScreen': jqScreen,

        'enter': function (ref, data) {
            codeq.loadProblemData(ref,data).then(function(problem){
                    //codeq.log.debug("then:"+JSON.stringify(problem));
                    enterFun(problem.generalProblemData,data.commonDef,problem.solution);
                })
                .fail(function (reason) {
                    codeq.log.error('Failed to obtain the problem definition: ' + reason, reason);
                    alert('Failed to obtain the problem definition: ' + reason);

                    history.back();//TODO test
                })
                .done();
        },
        'exit': function () {
            jqAllButtons.off(); // unregister all event handlers
            jqAllQuadrants.off();
            jqScreen.css('display', 'none');
            pythonHandler.destroy();
            pythonHandler = null;
            subScreens.destroy();
            subScreens = null;
            jqScreen.addClass('block1');

            $('#navigation-problem_list').css('display', 'none');
            var navigationPhython = $("#navigation-python");
            navigationPhython.removeClass("active");
            navigationPhython.css('display', 'none');
        }
    });

    jqDescription.data(stateNameTag, 'description');
    jqCode.data(stateNameTag, 'code');
    jqConsole.data(stateNameTag, 'console');
    jqInfo.data(stateNameTag, 'info');

    // a constant
    var firstCharacterPos = {'line': 0, 'ch': 0};

    var makePythonTerminalHandler = function (jqConsole, editor, problem_id, activityHandler) {
        var terminal = codeq.makeConsole(jqConsole, {
                'greeting': 'CodeQ Python terminal proxy',
                'autoHistory': true
            }),
            tcs = function terminalCommandSuccess (data) {
                if (data.code !== 0) {
                    terminal.append(data.message, 'error');
                }
            },
            tcf = function terminalCommandFailed (error) {
                terminal.append(error + '\n', 'error');
            };

        terminal.onInput = function (text) {
            terminal.leftmostCol = 0;
            activityHandler.queueTrace({'typ': 'python_input', 'txt': text + '\n'});
            return codeq.comms.sendPythonPush({
                'text': text + '\n'
            }).then(tcs, tcf);
        };

        codeq.comms.on('terminal_output', function (data) {
            var text = data.text,
                lines = text.split('\n');
            terminal.append(text, 'output');
            terminal.leftmostCol = lines[lines.length-1].length;
        });

        terminal.leftmostCol = 1;

        return terminal;
    };

    codeq.on('init', function (args) {
        codeq.tr.registerDictionary('python', codeq.tr.emptyDictionary); // to make the translator happy, when this screen is not active
    });

    var createPythonHandler = function (problemDef, commonDef, currentSolution) {
        var jqDescriptionContent = jqDescription.find('.description'),
            jqEditor = jqCode.find('.code_editor'),
            jqTerminal = jqConsole.find('.console'),
            jqHints = jqInfo.find('.hints'),
            editor = codeq.makeEditor(jqEditor[0],
                {
                    mode: 'python',
                    indentUnit: 4,
                    value: currentSolution || ''
                },
                function () {
                    jqTerminal.click()
                }),
            activityHandler = codeq.makeActivityHandler(editor, problemDef.id),
            terminal = makePythonTerminalHandler(jqTerminal, editor, problemDef.id, activityHandler),
            hinter = codeq.makeHinter(jqHints, jqEditor, editor, 'python_hints', problemDef, commonDef),
            commError = function (error) {
                alert(error);
            };

        codeq.template.processDictionary(problemDef.translations.description,
                [problemDef.language, problemDef.group, problemDef.problem]);
        codeq.tr.registerDictionary('python', problemDef.translations);
        codeq.tr.translateDom(jqScreen);
        jqBtnPlan.prop('disabled', !hinter.hasNextPlan());

        editor.on('change', function (instance, changeObj) {
            var doc = editor.getDoc(),
                pos = codeq.codePointCount(doc.getRange(firstCharacterPos, changeObj.from)),
                text;

            text = changeObj.removed.join('\n');
            if (text) {
                activityHandler.queueTrace({'typ': 'rm', 'off': pos, 'txt': text});
            }

            text = changeObj.text.join('\n');
            if (text) {
                activityHandler.queueTrace({'typ': 'ins', 'off': pos, 'txt': text});
            }
        });

        jqBtnPlan.on('click', function () {
            activityHandler.queueTrace({'typ': 'plan'});
            if (!hinter.planNext()) {
                jqBtnPlan.prop('disabled', true).blur();
            }
        });
        jqBtnHint.on('click', function () {
            editor.setOption('readOnly', true);
            jqBtnTest.prop('disabled', true);
            jqBtnHint.ladda('start');
            codeq.comms.sendHint({
                'language': 'python',
                'program': editor.getDoc().getValue(),
                'problem_id': problemDef.id
            })
            .then(function (data) {
                if (data.code === 0) {
                    activityHandler.queueTrace({'typ': 'hint', 'feedback': data.hints});
                    hinter.handle(data.hints);
                }
                else {
                    terminal.append('error: ' + data.message);
                }
            })
            .fail(commError)
            .fin(function () {
                editor.setOption('readOnly', false);
                jqBtnHint.ladda('stop');
                jqBtnTest.prop('disabled', false);
            })
            .done();
        });
        jqBtnTest.on('click', function () {
            editor.setOption('readOnly', true);
            jqBtnHint.prop('disabled', true);
            jqBtnTest.ladda('start');
            codeq.comms.sendTest({
                'language': 'python',
                'program': editor.getDoc().getValue(),
                'problem_id': problemDef.id
            })
            .then(function (data) {
                if (data.code === 0) {
                    activityHandler.queueTrace({'typ': 'test', 'feedback': data.hints});
                    hinter.handle(data.hints);
                }
                else {
                    terminal.append('error: ' + data.message);
                }
            })
            .fail(commError)
            .fin(function () {
                editor.setOption('readOnly', false);
                jqBtnTest.ladda('stop');
                jqBtnHint.prop('disabled', false);
            })
            .done();
        });
        jqBtnRun.on('click', function () {
            var program = editor.getDoc().getValue();
            activityHandler.queueTrace({'typ': 'python_run', 'program': program});
            codeq.comms.sendPythonStop({})
            .then(function () {
                codeq.comms.sendPythonExec({
                    'program': program
                });
            })
            .fail(commError)
            .done();
            // focus the terminal
            jqTerminal.click();
        });
        jqBtnStop.on('click', function () {
            activityHandler.queueTrace({'typ': 'python_stop'});
            codeq.comms.sendPythonStop({})
            .fail(commError)
            .done();
        });

        codeq.comms.loadProblem(problemDef.id).done();
        activityHandler.queueTrace({
            'typ': 'open',
            'time': Date.now(),
            'content': editor.getDoc().getValue()
        });

        return {
            destroy: function () {
                codeq.comms.endProblem().done();
                $('#screen_python .title').text('');//empty the title text
                jqAllButtons.off();
                editor.off('change');
                codeq.comms.off('terminal_output'); // stop listening for the terminal events from server
                activityHandler.queueTrace({'typ': 'close'});
                activityHandler.flush();
                hinter.destroy();
                terminal.destroy();
                jqDescriptionContent.empty();
                jqEditor.empty(); // TODO: perhaps you do not want to "free" the editor, just empty it
                jqTerminal.empty(); // TODO: the same with the console
                jqDescriptionContent = null;
                jqEditor = null;
                jqTerminal = null;
                jqHints = null;
                codeq.tr.registerDictionary('python', codeq.tr.emptyDictionary);
            }
        };
    };
})();