diff --git a/misc/editors/meta.js b/misc/editors/meta.js new file mode 100644 index 000000000..1027c2ffe --- /dev/null +++ b/misc/editors/meta.js @@ -0,0 +1,218 @@ +// CodeMirror, copyright (c) by Marijn Haverbeke and others +// Distributed under an MIT license: http://codemirror.net/LICENSE + +(function(mod) { + if (typeof exports == "object" && typeof module == "object") // CommonJS + mod(require("../lib/codemirror")); + else if (typeof define == "function" && define.amd) // AMD + define(["../lib/codemirror"], mod); + else // Plain browser env + mod(CodeMirror); +})(function(CodeMirror) { + "use strict"; + + CodeMirror.modeInfo = [ + {name: "APL", mime: "text/apl", mode: "apl", ext: ["dyalog", "apl"]}, + {name: "PGP", mimes: ["application/pgp", "application/pgp-encrypted", "application/pgp-keys", "application/pgp-signature"], mode: "asciiarmor", ext: ["asc", "pgp", "sig"]}, + {name: "ASN.1", mime: "text/x-ttcn-asn", mode: "asn.1", ext: ["asn", "asn1"]}, + {name: "Asterisk", mime: "text/x-asterisk", mode: "asterisk", file: /^extensions\.conf$/i}, + {name: "Brainfuck", mime: "text/x-brainfuck", mode: "brainfuck", ext: ["b", "bf"]}, + {name: "C", mime: "text/x-csrc", mode: "clike", ext: ["c", "h", "ino"]}, + {name: "C++", mime: "text/x-c++src", mode: "clike", ext: ["cpp", "c++", "cc", "cxx", "hpp", "h++", "hh", "hxx"], alias: ["cpp"]}, + {name: "Cobol", mime: "text/x-cobol", mode: "cobol", ext: ["cob", "cpy"]}, + {name: "C#", mime: "text/x-csharp", mode: "clike", ext: ["cs"], alias: ["csharp"]}, + {name: "Clojure", mime: "text/x-clojure", mode: "clojure", ext: ["clj", "cljc", "cljx"]}, + {name: "ClojureScript", mime: "text/x-clojurescript", mode: "clojure", ext: ["cljs"]}, + {name: "Closure Stylesheets (GSS)", mime: "text/x-gss", mode: "css", ext: ["gss"]}, + {name: "CMake", mime: "text/x-cmake", mode: "cmake", ext: ["cmake", "cmake.in"], file: /^CMakeLists.txt$/}, + {name: "CoffeeScript", mimes: ["application/vnd.coffeescript", "text/coffeescript", "text/x-coffeescript"], mode: "coffeescript", ext: ["coffee"], alias: ["coffee", "coffee-script"]}, + {name: "Common Lisp", mime: "text/x-common-lisp", mode: "commonlisp", ext: ["cl", "lisp", "el"], alias: ["lisp"]}, + {name: "Cypher", mime: "application/x-cypher-query", mode: "cypher", ext: ["cyp", "cypher"]}, + {name: "Cython", mime: "text/x-cython", mode: "python", ext: ["pyx", "pxd", "pxi"]}, + {name: "Crystal", mime: "text/x-crystal", mode: "crystal", ext: ["cr"]}, + {name: "CSS", mime: "text/css", mode: "css", ext: ["css"]}, + {name: "CQL", mime: "text/x-cassandra", mode: "sql", ext: ["cql"]}, + {name: "D", mime: "text/x-d", mode: "d", ext: ["d"]}, + {name: "Dart", mimes: ["application/dart", "text/x-dart"], mode: "dart", ext: ["dart"]}, + {name: "diff", mime: "text/x-diff", mode: "diff", ext: ["diff", "patch"]}, + {name: "Django", mime: "text/x-django", mode: "django"}, + {name: "Dockerfile", mime: "text/x-dockerfile", mode: "dockerfile", file: /^Dockerfile$/}, + {name: "DTD", mime: "application/xml-dtd", mode: "dtd", ext: ["dtd"]}, + {name: "Dylan", mime: "text/x-dylan", mode: "dylan", ext: ["dylan", "dyl", "intr"]}, + {name: "EBNF", mime: "text/x-ebnf", mode: "ebnf"}, + {name: "ECL", mime: "text/x-ecl", mode: "ecl", ext: ["ecl"]}, + {name: "edn", mime: "application/edn", mode: "clojure", ext: ["edn"]}, + {name: "Eiffel", mime: "text/x-eiffel", mode: "eiffel", ext: ["e"]}, + {name: "Elm", mime: "text/x-elm", mode: "elm", ext: ["elm"]}, + {name: "Embedded Javascript", mime: "application/x-ejs", mode: "htmlembedded", ext: ["ejs"]}, + {name: "Embedded Ruby", mime: "application/x-erb", mode: "htmlembedded", ext: ["erb"]}, + {name: "Erlang", mime: "text/x-erlang", mode: "erlang", ext: ["erl"]}, + {name: "Esper", mime: "text/x-esper", mode: "sql"}, + {name: "Factor", mime: "text/x-factor", mode: "factor", ext: ["factor"]}, + {name: "FCL", mime: "text/x-fcl", mode: "fcl"}, + {name: "Forth", mime: "text/x-forth", mode: "forth", ext: ["forth", "fth", "4th"]}, + {name: "Fortran", mime: "text/x-fortran", mode: "fortran", ext: ["f", "for", "f77", "f90"]}, + {name: "F#", mime: "text/x-fsharp", mode: "mllike", ext: ["fs"], alias: ["fsharp"]}, + {name: "Gas", mime: "text/x-gas", mode: "gas", ext: ["s"]}, + {name: "Gherkin", mime: "text/x-feature", mode: "gherkin", ext: ["feature"]}, + {name: "GitHub Flavored Markdown", mime: "text/x-gfm", mode: "gfm", file: /^(readme|contributing|history).md$/i}, + {name: "Go", mime: "text/x-go", mode: "go", ext: ["go"]}, + {name: "Groovy", mime: "text/x-groovy", mode: "groovy", ext: ["groovy", "gradle"], file: /^Jenkinsfile$/}, + {name: "HAML", mime: "text/x-haml", mode: "haml", ext: ["haml"]}, + {name: "Haskell", mime: "text/x-haskell", mode: "haskell", ext: ["hs"]}, + {name: "Haskell (Literate)", mime: "text/x-literate-haskell", mode: "haskell-literate", ext: ["lhs"]}, + {name: "Haxe", mime: "text/x-haxe", mode: "haxe", ext: ["hx"]}, + {name: "HXML", mime: "text/x-hxml", mode: "haxe", ext: ["hxml"]}, + {name: "ASP.NET", mime: "application/x-aspx", mode: "htmlembedded", ext: ["aspx"], alias: ["asp", "aspx"]}, + {name: "HTML", mime: "text/html", mode: "htmlmixed", ext: ["html", "htm", "handlebars", "hbs"], alias: ["xhtml"]}, + {name: "HTTP", mime: "message/http", mode: "http"}, + {name: "IDL", mime: "text/x-idl", mode: "idl", ext: ["pro"]}, + {name: "Pug", mime: "text/x-pug", mode: "pug", ext: ["jade", "pug"], alias: ["jade"]}, + {name: "Java", mime: "text/x-java", mode: "clike", ext: ["java"]}, + {name: "Java Server Pages", mime: "application/x-jsp", mode: "htmlembedded", ext: ["jsp"], alias: ["jsp"]}, + {name: "JavaScript", mimes: ["text/javascript", "text/ecmascript", "application/javascript", "application/x-javascript", "application/ecmascript"], + mode: "javascript", ext: ["js"], alias: ["ecmascript", "js", "node"]}, + {name: "JSON", mimes: ["application/json", "application/x-json"], mode: "javascript", ext: ["json", "map"], alias: ["json5"]}, + {name: "JSON-LD", mime: "application/ld+json", mode: "javascript", ext: ["jsonld"], alias: ["jsonld"]}, + {name: "JSX", mime: "text/jsx", mode: "jsx", ext: ["jsx"]}, + {name: "Jinja2", mime: "null", mode: "jinja2"}, + {name: "Julia", mime: "text/x-julia", mode: "julia", ext: ["jl"]}, + {name: "Kotlin", mime: "text/x-kotlin", mode: "clike", ext: ["kt"]}, + {name: "LESS", mime: "text/x-less", mode: "css", ext: ["less"]}, + {name: "LiveScript", mime: "text/x-livescript", mode: "livescript", ext: ["ls"], alias: ["ls"]}, + {name: "Lua", mime: "text/x-lua", mode: "lua", ext: ["lua"]}, + {name: "Markdown", mime: "text/x-markdown", mode: "markdown", ext: ["markdown", "md", "mkd"]}, + {name: "mIRC", mime: "text/mirc", mode: "mirc"}, + {name: "MariaDB SQL", mime: "text/x-mariadb", mode: "sql"}, + {name: "Mathematica", mime: "text/x-mathematica", mode: "mathematica", ext: ["m", "nb"]}, + {name: "Modelica", mime: "text/x-modelica", mode: "modelica", ext: ["mo"]}, + {name: "MUMPS", mime: "text/x-mumps", mode: "mumps", ext: ["mps"]}, + {name: "MS SQL", mime: "text/x-mssql", mode: "sql"}, + {name: "mbox", mime: "application/mbox", mode: "mbox", ext: ["mbox"]}, + {name: "MySQL", mime: "text/x-mysql", mode: "sql"}, + {name: "Nginx", mime: "text/x-nginx-conf", mode: "nginx", file: /nginx.*\.conf$/i}, + {name: "NSIS", mime: "text/x-nsis", mode: "nsis", ext: ["nsh", "nsi"]}, + {name: "NTriples", mimes: ["application/n-triples", "application/n-quads", "text/n-triples"], + mode: "ntriples", ext: ["nt", "nq"]}, + {name: "Objective-C", mime: "text/x-objectivec", mode: "clike", ext: ["m", "mm"], alias: ["objective-c", "objc"]}, + {name: "OCaml", mime: "text/x-ocaml", mode: "mllike", ext: ["ml", "mli", "mll", "mly"]}, + {name: "Octave", mime: "text/x-octave", mode: "octave", ext: ["m"]}, + {name: "Oz", mime: "text/x-oz", mode: "oz", ext: ["oz"]}, + {name: "Pascal", mime: "text/x-pascal", mode: "pascal", ext: ["p", "pas"]}, + {name: "PEG.js", mime: "null", mode: "pegjs", ext: ["jsonld"]}, + {name: "Perl", mime: "text/x-perl", mode: "perl", ext: ["pl", "pm"]}, + {name: "PHP", mimes: ["text/x-php", "application/x-httpd-php", "application/x-httpd-php-open"], mode: "php", ext: ["php", "php3", "php4", "php5", "php7", "phtml"]}, + {name: "Pig", mime: "text/x-pig", mode: "pig", ext: ["pig"]}, + {name: "Plain Text", mime: "text/plain", mode: "null", ext: ["txt", "text", "conf", "def", "list", "log"]}, + {name: "PLSQL", mime: "text/x-plsql", mode: "sql", ext: ["pls"]}, + {name: "PowerShell", mime: "application/x-powershell", mode: "powershell", ext: ["ps1", "psd1", "psm1"]}, + {name: "Prolog", mime: "application/x-prolog", mode: "prolog", ext: ["yap", "ypp", "pl", "prolog"]}, + {name: "Properties files", mime: "text/x-properties", mode: "properties", ext: ["properties", "ini", "in"], alias: ["ini", "properties"]}, + {name: "ProtoBuf", mime: "text/x-protobuf", mode: "protobuf", ext: ["proto"]}, + {name: "Python", mime: "text/x-python", mode: "python", ext: ["BUILD", "bzl", "py", "pyw"], file: /^(BUCK|BUILD)$/}, + {name: "Puppet", mime: "text/x-puppet", mode: "puppet", ext: ["pp"]}, + {name: "Q", mime: "text/x-q", mode: "q", ext: ["q"]}, + {name: "R", mime: "text/x-rsrc", mode: "r", ext: ["r", "R"], alias: ["rscript"]}, + {name: "reStructuredText", mime: "text/x-rst", mode: "rst", ext: ["rst"], alias: ["rst"]}, + {name: "RPM Changes", mime: "text/x-rpm-changes", mode: "rpm"}, + {name: "RPM Spec", mime: "text/x-rpm-spec", mode: "rpm", ext: ["spec"]}, + {name: "Ruby", mime: "text/x-ruby", mode: "ruby", ext: ["rb"], alias: ["jruby", "macruby", "rake", "rb", "rbx"]}, + {name: "Rust", mime: "text/x-rustsrc", mode: "rust", ext: ["rs"]}, + {name: "SAS", mime: "text/x-sas", mode: "sas", ext: ["sas"]}, + {name: "Sass", mime: "text/x-sass", mode: "sass", ext: ["sass"]}, + {name: "Scala", mime: "text/x-scala", mode: "clike", ext: ["scala"]}, + {name: "Scheme", mime: "text/x-scheme", mode: "scheme", ext: ["scm", "ss"]}, + {name: "SCSS", mime: "text/x-scss", mode: "css", ext: ["scss"]}, + {name: "Shell", mimes: ["text/x-sh", "application/x-sh"], mode: "shell", ext: ["sh", "ksh", "bash"], alias: ["bash", "sh", "zsh"], file: /^PKGBUILD$/}, + {name: "Sieve", mime: "application/sieve", mode: "sieve", ext: ["siv", "sieve"]}, + {name: "Slim", mimes: ["text/x-slim", "application/x-slim"], mode: "slim", ext: ["slim"]}, + {name: "Smalltalk", mime: "text/x-stsrc", mode: "smalltalk", ext: ["st"]}, + {name: "Smarty", mime: "text/x-smarty", mode: "smarty", ext: ["tpl"]}, + {name: "Solr", mime: "text/x-solr", mode: "solr"}, + {name: "SML", mime: "text/x-sml", mode: "mllike", ext: ["sml", "sig", "fun", "smackspec"]}, + {name: "Soy", mime: "text/x-soy", mode: "soy", ext: ["soy"], alias: ["closure template"]}, + {name: "SPARQL", mime: "application/sparql-query", mode: "sparql", ext: ["rq", "sparql"], alias: ["sparul"]}, + {name: "Spreadsheet", mime: "text/x-spreadsheet", mode: "spreadsheet", alias: ["excel", "formula"]}, + {name: "SQL", mime: "text/x-sql", mode: "sql", ext: ["sql"]}, + {name: "SQLite", mime: "text/x-sqlite", mode: "sql"}, + {name: "Squirrel", mime: "text/x-squirrel", mode: "clike", ext: ["nut"]}, + {name: "Stylus", mime: "text/x-styl", mode: "stylus", ext: ["styl"]}, + {name: "Swift", mime: "text/x-swift", mode: "swift", ext: ["swift"]}, + {name: "sTeX", mime: "text/x-stex", mode: "stex"}, + {name: "LaTeX", mime: "text/x-latex", mode: "stex", ext: ["text", "ltx", "tex"], alias: ["tex"]}, + {name: "SystemVerilog", mime: "text/x-systemverilog", mode: "verilog", ext: ["v", "sv", "svh"]}, + {name: "Tcl", mime: "text/x-tcl", mode: "tcl", ext: ["tcl"]}, + {name: "Textile", mime: "text/x-textile", mode: "textile", ext: ["textile"]}, + {name: "TiddlyWiki ", mime: "text/x-tiddlywiki", mode: "tiddlywiki"}, + {name: "Tiki wiki", mime: "text/tiki", mode: "tiki"}, + {name: "TOML", mime: "text/x-toml", mode: "toml", ext: ["toml"]}, + {name: "Tornado", mime: "text/x-tornado", mode: "tornado"}, + {name: "troff", mime: "text/troff", mode: "troff", ext: ["1", "2", "3", "4", "5", "6", "7", "8", "9"]}, + {name: "TTCN", mime: "text/x-ttcn", mode: "ttcn", ext: ["ttcn", "ttcn3", "ttcnpp"]}, + {name: "TTCN_CFG", mime: "text/x-ttcn-cfg", mode: "ttcn-cfg", ext: ["cfg"]}, + {name: "Turtle", mime: "text/turtle", mode: "turtle", ext: ["ttl"]}, + {name: "TypeScript", mime: "application/typescript", mode: "javascript", ext: ["ts"], alias: ["ts"]}, + {name: "TypeScript-JSX", mime: "text/typescript-jsx", mode: "jsx", ext: ["tsx"], alias: ["tsx"]}, + {name: "Twig", mime: "text/x-twig", mode: "twig"}, + {name: "Web IDL", mime: "text/x-webidl", mode: "webidl", ext: ["webidl"]}, + {name: "VB.NET", mime: "text/x-vb", mode: "vb", ext: ["vb"]}, + {name: "VBScript", mime: "text/vbscript", mode: "vbscript", ext: ["vbs"]}, + {name: "Velocity", mime: "text/velocity", mode: "velocity", ext: ["vtl"]}, + {name: "Verilog", mime: "text/x-verilog", mode: "verilog", ext: ["v"]}, + {name: "VHDL", mime: "text/x-vhdl", mode: "vhdl", ext: ["vhd", "vhdl"]}, + {name: "Vue.js Component", mimes: ["script/x-vue", "text/x-vue"], mode: "vue", ext: ["vue"]}, + {name: "XML", mimes: ["application/xml", "text/xml"], mode: "xml", ext: ["xml", "xsl", "xsd", "svg"], alias: ["rss", "wsdl", "xsd"]}, + {name: "XQuery", mime: "application/xquery", mode: "xquery", ext: ["xy", "xquery"]}, + {name: "Yacas", mime: "text/x-yacas", mode: "yacas", ext: ["ys"]}, + {name: "YAML", mimes: ["text/x-yaml", "text/yaml"], mode: "yaml", ext: ["yaml", "yml"], alias: ["yml"]}, + {name: "Z80", mime: "text/x-z80", mode: "z80", ext: ["z80"]}, + {name: "mscgen", mime: "text/x-mscgen", mode: "mscgen", ext: ["mscgen", "mscin", "msc"]}, + {name: "xu", mime: "text/x-xu", mode: "mscgen", ext: ["xu"]}, + {name: "msgenny", mime: "text/x-msgenny", mode: "mscgen", ext: ["msgenny"]} + ]; + // Ensure all modes have a mime property for backwards compatibility + for (var i = 0; i < CodeMirror.modeInfo.length; i++) { + var info = CodeMirror.modeInfo[i]; + if (info.mimes) info.mime = info.mimes[0]; + } + + CodeMirror.findModeByMIME = function(mime) { + mime = mime.toLowerCase(); + for (var i = 0; i < CodeMirror.modeInfo.length; i++) { + var info = CodeMirror.modeInfo[i]; + if (info.mime == mime) return info; + if (info.mimes) for (var j = 0; j < info.mimes.length; j++) + if (info.mimes[j] == mime) return info; + } + if (/\+xml$/.test(mime)) return CodeMirror.findModeByMIME("application/xml") + if (/\+json$/.test(mime)) return CodeMirror.findModeByMIME("application/json") + }; + + CodeMirror.findModeByExtension = function(ext) { + for (var i = 0; i < CodeMirror.modeInfo.length; i++) { + var info = CodeMirror.modeInfo[i]; + if (info.ext) for (var j = 0; j < info.ext.length; j++) + if (info.ext[j] == ext) return info; + } + }; + + CodeMirror.findModeByFileName = function(filename) { + for (var i = 0; i < CodeMirror.modeInfo.length; i++) { + var info = CodeMirror.modeInfo[i]; + if (info.file && info.file.test(filename)) return info; + } + var dot = filename.lastIndexOf("."); + var ext = dot > -1 && filename.substring(dot + 1, filename.length); + if (ext) return CodeMirror.findModeByExtension(ext); + }; + + CodeMirror.findModeByName = function(name) { + name = name.toLowerCase(); + for (var i = 0; i < CodeMirror.modeInfo.length; i++) { + var info = CodeMirror.modeInfo[i]; + if (info.name.toLowerCase() == name) return info; + if (info.alias) for (var j = 0; j < info.alias.length; j++) + if (info.alias[j].toLowerCase() == name) return info; + } + }; +}); diff --git a/misc/editors/mode.js b/misc/editors/mode.js new file mode 100644 index 000000000..b5b567812 --- /dev/null +++ b/misc/editors/mode.js @@ -0,0 +1,115 @@ +"use strict"; +// Copyright (c) Jupyter Development Team. +// Distributed under the terms of the Modified BSD License. +Object.defineProperty(exports, "__esModule", { value: true }); +var codeeditor_1 = require("@jupyterlab/codeeditor"); +var CodeMirror = require("codemirror"); +require("codemirror/mode/meta"); +require("codemirror/addon/runmode/runmode"); +require("./codemirror-ipython"); +require("./codemirror-ipythongfm"); +// Bundle other common modes +require("codemirror/mode/javascript/javascript"); +require("codemirror/mode/css/css"); +require("codemirror/mode/prolog/prolog"); +require("codemirror/mode/julia/julia"); +require("codemirror/mode/r/r"); +require("codemirror/mode/markdown/markdown"); +require("codemirror/mode/clike/clike"); +require("codemirror/mode/shell/shell"); +require("codemirror/mode/sql/sql"); +var coreutils_1 = require("@jupyterlab/coreutils"); +/** + * The namespace for CodeMirror Mode functionality. + */ +var Mode; +(function (Mode) { + /** + * Get the raw list of available modes specs. + */ + function getModeInfo() { + return CodeMirror.modeInfo; + } + Mode.getModeInfo = getModeInfo; + /** + * Running a CodeMirror mode outside of an editor. + */ + function run(code, mode, el) { + CodeMirror.runMode(code, mode, el); + } + Mode.run = run; + /** + * Ensure a codemirror mode is available by name or Codemirror spec. + * + * @param mode - The mode to ensure. If it is a string, uses [findBest] + * to get the appropriate spec. + * + * @returns A promise that resolves when the mode is available. + */ + function ensure(mode) { + var spec = findBest(mode); + // Simplest, cheapest check by mode name. + if (CodeMirror.modes.hasOwnProperty(spec.mode)) { + return Promise.resolve(spec); + } + // Fetch the mode asynchronously. + return new Promise(function (resolve, reject) { + require(["codemirror/mode/" + spec.mode + "/" + spec.mode + ".js"], function () { + resolve(spec); + }); + }); + } + Mode.ensure = ensure; + /** + * Find a codemirror mode by name or CodeMirror spec. + */ + function findBest(mode) { + var modename = (typeof mode === 'string') ? mode : + mode.mode || mode.name; + var mimetype = (typeof mode !== 'string') ? mode.mime : modename; + var ext = (typeof mode !== 'string') ? mode.ext : []; + return (CodeMirror.findModeByName(modename || '') || + CodeMirror.findModeByMIME(mimetype || '') || + findByExtension(ext) || + CodeMirror.findModeByMIME(codeeditor_1.IEditorMimeTypeService.defaultMimeType) || + CodeMirror.findModeByMIME('text/plain')); + } + Mode.findBest = findBest; + /** + * Find a codemirror mode by MIME. + */ + function findByMIME(mime) { + return CodeMirror.findModeByMIME(mime); + } + Mode.findByMIME = findByMIME; + /** + * Find a codemirror mode by name. + */ + function findByName(name) { + return CodeMirror.findModeByName(name); + } + Mode.findByName = findByName; + /** + * Find a codemirror mode by filename. + */ + function findByFileName(name) { + var basename = coreutils_1.PathExt.basename(name); + return CodeMirror.findModeByFileName(basename); + } + Mode.findByFileName = findByFileName; + /** + * Find a codemirror mode by extension. + */ + function findByExtension(ext) { + if (typeof ext === 'string') { + return CodeMirror.findModeByExtension(name); + } + for (var i = 0; i < ext.length; i++) { + var mode = CodeMirror.findModeByExtension(ext[i]); + if (mode) { + return mode; + } + } + } + Mode.findByExtension = findByExtension; +})(Mode = exports.Mode || (exports.Mode = {})); diff --git a/misc/editors/webpack.config.js b/misc/editors/webpack.config.js new file mode 100644 index 000000000..5a93a3980 --- /dev/null +++ b/misc/editors/webpack.config.js @@ -0,0 +1,188 @@ +/*----------------------------------------------------------------------------- +| Copyright (c) Jupyter Development Team. +| Distributed under the terms of the Modified BSD License. +|----------------------------------------------------------------------------*/ + +var path = require('path'); +var fs = require('fs-extra'); +var Handlebars = require('handlebars'); +var HtmlWebpackPlugin = require('html-webpack-plugin'); +var webpack = require('webpack'); + +var Build = require('@jupyterlab/buildutils').Build; +var package_data = require('./package.json'); + +// Handle the extensions. +var jlab = package_data.jupyterlab; +var extensions = jlab.extensions; +var mimeExtensions = jlab.mimeExtensions; +Build.ensureAssets({ + packageNames: Object.keys(mimeExtensions).concat(Object.keys(extensions)), + output: jlab.outputDir +}); + +fs.ensureDirSync('node_modules/codemirror/mode/prolog'); +fs.copySync(path.join(path.resolve(jlab.buildDir),'../../../kernels/yap_kernel/prolog.js'), 'node_modules/codemirror/mode/prolog/prolog.js'); +fs.copySync(path.join(path.resolve(jlab.buildDir),'../../../kernels/yap_kernel/meta.js'), 'node_modules/codemirror/mode/meta.js'); + +// Create the entry point file. +var source = fs.readFileSync('index.js').toString(); +var template = Handlebars.compile(source); +var data = { + jupyterlab_extensions: extensions, + jupyterlab_mime_extensions: mimeExtensions, +}; +var result = template(data); + +// Ensure a clear build directory. +var buildDir = path.resolve(jlab.buildDir); +if (fs.existsSync(buildDir)) { + fs.removeSync(buildDir); +} +fs.ensureDirSync(buildDir); + + +fs.writeFileSync(path.join(buildDir, 'index.out.js'), result); +fs.copySync('./package.json', path.join(buildDir, 'package.json')); +fs.copySync('./templates/error.html', path.join(buildDir, 'error.html')); + +// Set up variables for watch mode. +var localLinked = {}; +var ignoreCache = Object.create(null); +Object.keys(jlab.linkedPackages).forEach(function (name) { + var localPath = require.resolve(path.join(name, 'package.json')); + localLinked[name] = path.dirname(localPath); +}); + + +/** + * Sync a local path to a linked package path if they are files and differ. + */ +function maybeSync(localPath, name, rest) { + var stats = fs.statSync(localPath); + if (!stats.isFile(localPath)) { + return; + } + var source = fs.realpathSync(path.join(jlab.linkedPackages[name], rest)); + if (source === fs.realpathSync(localPath)) { + return; + } + fs.watchFile(source, { 'interval': 500 }, function(curr) { + if (!curr || curr.nlink === 0) { + return; + } + try { + fs.copySync(source, localPath); + } catch (err) { + console.error(err); + } + }); +} + + +/** + * A WebPack Plugin that copies the assets to the static directory. + */ +function JupyterLabPlugin() { } + +JupyterLabPlugin.prototype.apply = function(compiler) { + + compiler.plugin('after-emit', function(compilation, callback) { + var staticDir = jlab.staticDir; + if (!staticDir) { + callback(); + return; + } + // Ensure a clean static directory on the first emit. + if (this._first && fs.existsSync(staticDir)) { + fs.removeSync(staticDir); + } + this._first = false; + fs.copySync(buildDir, staticDir); + callback(); + }.bind(this)); +}; + +JupyterLabPlugin.prototype._first = true; + + +module.exports = { + entry: { + main: ['whatwg-fetch', path.resolve(buildDir, 'index.out.js')], + vendor: jlab.vendor + }, + output: { + path: path.resolve(buildDir), + publicPath: jlab.publicUrl || '{{base_url}}lab/static/', + filename: '[name].[chunkhash].js' + }, + module: { + rules: [ + { test: /^codemirror$/, use: 'file-loader' }, + { test: /^JUPYTERLAB_RAW_LOADER_/, use: 'raw-loader' }, + { test: /^JUPYTERLAB_URL_LOADER_/, use: 'url-loader?limit=10000' }, + { test: /^JUPYTERLAB_FILE_LOADER_/, use: 'file-loader' }, + { test: /\.css$/, use: ['style-loader', 'css-loader'] }, + { test: /\.json$/, use: 'json-loader' }, + { test: /\.md$/, use: 'raw-loader' }, + { test: /\.txt$/, use: 'raw-loader' }, + { test: /\.js$/, use: ['source-map-loader'], enforce: 'pre', + // eslint-disable-next-line no-undef + exclude: path.join(process.cwd(), 'node_modules') + }, + { test: /\.(jpg|png|gif)$/, use: 'file-loader' }, + { test: /\.js.map$/, use: 'file-loader' }, + { test: /\.woff2(\?v=\d+\.\d+\.\d+)?$/, use: 'url-loader?limit=10000&mimetype=application/font-woff' }, + { test: /\.woff(\?v=\d+\.\d+\.\d+)?$/, use: 'url-loader?limit=10000&mimetype=application/font-woff' }, + { test: /\.ttf(\?v=\d+\.\d+\.\d+)?$/, use: 'url-loader?limit=10000&mimetype=application/octet-stream' }, + { test: /\.otf(\?v=\d+\.\d+\.\d+)?$/, use: 'url-loader?limit=10000&mimetype=application/octet-stream' }, + { test: /\.eot(\?v=\d+\.\d+\.\d+)?$/, use: 'file-loader' }, + { test: /\.svg(\?v=\d+\.\d+\.\d+)?$/, use: 'url-loader?limit=10000&mimetype=image/svg+xml' } + ], + }, + watchOptions: { + ignored: function(localPath) { + localPath = path.resolve(localPath); + if (localPath in ignoreCache) { + return ignoreCache[localPath]; + } + // Limit the watched files to those in our local linked package dirs. + var ignore = true; + Object.keys(localLinked).some(function (name) { + // Bail if already found. + var rootPath = localLinked[name]; + var contained = localPath.indexOf(rootPath + path.sep) !== -1; + if (localPath !== rootPath && !contained) { + return false; + } + var rest = localPath.slice(rootPath.length); + if (rest.indexOf('node_modules') === -1) { + ignore = false; + maybeSync(localPath, name, rest); + } + return true; + }); + ignoreCache[localPath] = ignore; + return ignore; + } + }, + node: { + fs: 'empty' + }, + bail: true, + devtool: 'source-map', + plugins: [ + new HtmlWebpackPlugin({ + template: path.join('templates', 'template.html'), + title: jlab.name || 'JupyterLab' + }), + new webpack.HashedModuleIdsPlugin(), + new webpack.optimize.CommonsChunkPlugin({ + name: 'vendor' + }), + new webpack.optimize.CommonsChunkPlugin({ + name: 'manifest' + }), + new JupyterLabPlugin({}) + ] +}; diff --git a/packages/python/pl2py.c b/packages/python/pl2py.c index feb1ae579..e20b6d08d 100644 --- a/packages/python/pl2py.c +++ b/packages/python/pl2py.c @@ -14,6 +14,8 @@ PyObject *YE(term_t t, int line, const char *file, const char *code) { return NULL; } + + PyObject *YEC(PyObject *f, PyObject *a, PyObject *d, int line, const char *file, const char *code) { fprintf(stderr, "**** Warning,%s@%s:%d: failed on Python call \n", code, @@ -24,12 +26,48 @@ PyObject *YEC(PyObject *f, PyObject *a, PyObject *d, int line, const char *file, fprintf(stderr,""); if (a) PyObject_Print(a, stderr, 0); - if (a) - PyObject_Print(a, stderr, 0); + if (d) + PyObject_Print(d, stderr, 0); fprintf(stderr,"\n"); return NULL; } - void YEM(const char *exp, int line, const char *file, const char *code) { + +PyObject *YED2(PyObject *f, PyObject *a, PyObject *d, int line, const char *file, const char *code) { + + fprintf(stderr, "**** Warning,%s@%s:%d: failed on Python call \n", code, + file, line); + if (f) + PyObject_Print(f, stderr, 0); + else + fprintf(stderr,""); + fprintf(stderr,"("); + if (a) + PyObject_Print(a, stderr, 0); + fprintf(stderr,","); + if (d) + PyObject_Print(d, stderr, 0); + fprintf(stderr,")\n"); + return NULL; + +} + +PyObject *YED1(PyObject *f, PyObject *a, int line, const char *file, const char *code) { + + fprintf(stderr, "**** Warning,%s@%s:%d: failed on Python call \n", code, + file, line); + if (f) + PyObject_Print(f, stderr, 0); + else + fprintf(stderr,""); + fprintf(stderr,"("); + if (a) + PyObject_Print(a, stderr, 0); + fprintf(stderr,")\n"); + return NULL; + +} + +void YEM(const char *exp, int line, const char *file, const char *code) { fprintf(stderr, "**** Warning,%s@%s:%d: failed while executing %s\n", code, file, line, exp); } @@ -305,7 +343,10 @@ PyObject *term_to_python(term_t t, bool eval, PyObject *o, bool cvt) { } if (fun == FUNCTOR_brackets1) { AOK(PL_get_arg(1, t, t), NULL); - return term_to_python(t, true, NULL, true); + PyObject *ys = term_to_python(t, true, o, true), *rc; + PyObject_Print(ys,stderr,0);fprintf(stderr, "--- \n"); + CHECK_CALL(ys, PyTuple_New(0), NULL); + return rc; } if (fun == FUNCTOR_complex2) { term_t targ = PL_new_term_ref(); diff --git a/packages/python/py2pl.c b/packages/python/py2pl.c index 3cf2795c6..46ba1f7df 100644 --- a/packages/python/py2pl.c +++ b/packages/python/py2pl.c @@ -131,7 +131,7 @@ else { else if (PyList_Check(pVal)) { Py_ssize_t i, sz = PyList_GET_SIZE(pVal); if (sz == 0) - return TermNil; + return repr_term(pVal); Term t = TermNil; for (i = sz; i > 0; --i) { PyObject *p = PyTuple_GetItem(pVal, i); @@ -152,7 +152,7 @@ else if (PyDict_Check(pVal)) { PyObject *key, *value; Term f, *opt = &f, t; if (left == 0) { - return ATOM_curly_brackets; + return repr_term(pVal); } else { while (PyDict_Next(pVal, &pos, &key, &value)) { Term t0[2], to; @@ -177,10 +177,8 @@ else if (PyDict_Check(pVal)) { } foreign_t python_to_term(PyObject *pVal, term_t t) { - term_t t0 = PL_new_term_ref(); - bool rc = python_to_term__(pVal); - PL_reset_term_refs(t0); - return rc; + Term o = python_to_term__(pVal); + return YAP_Unify(o,YAP_GetFromSlot(t)); } // extern bool Yap_do_low_level_trace; @@ -228,6 +226,17 @@ bool python_assign(term_t t, PyObject *exp, PyObject *context) { return python_to_term(exp, t); } + case PL_STRING: { + char *s = NULL; + size_t l; + PL_get_string_chars(t, &s,&l); + if (!context) + context = py_Main; + if (PyObject_SetAttrString(context, s, exp) == 0) + return true; + PyErr_Print(); + return false; + } case PL_ATOM: { char *s = NULL; PL_get_atom_chars(t, &s); @@ -238,7 +247,6 @@ bool python_assign(term_t t, PyObject *exp, PyObject *context) { PyErr_Print(); return false; } - case PL_STRING: case PL_INTEGER: case PL_FLOAT: // domain or type erro? diff --git a/packages/python/py4yap.h b/packages/python/py4yap.h index db881bf01..08ef95da8 100644 --- a/packages/python/py4yap.h +++ b/packages/python/py4yap.h @@ -25,6 +25,8 @@ #include +#include + #include #ifdef HAVE_STAT #undef HAVE_STATa @@ -156,6 +158,28 @@ static inline PyObject *atom_to_python_string(term_t t) { PyErr_Clear(); \ } +extern PyObject *YED2(PyObject *f, PyObject *a, PyObject *d, int line, const char *file, const char *code); + +static inline PyObject *CALL_BIP2(PyObject *ys,PyObject * pArg1,PyObject * pArg2) +{ PyErr_Clear(); \ + PyObject *rc = PyObject_CallFunctionObjArgs(ys, pArg1, pArg2, NULL); \ + if (rc == NULL || PyErr_Occurred()) { \ + YED2(ys, pArg1, pArg2, __LINE__, __FILE__, __FUNCTION__); \ + PyErr_Print(); \ + PyErr_Clear(); \ + } + return rc; +} + +#define CALL_BIP1(ys, pArg1) \ + PyErr_Clear(); \ + rc = PyObject_CallFunctionObjArgs(ys, pArg1, NULL); \ + if (rc == NULL || PyErr_Occurred()) { \ + YED1(ys, pArg1, __LINE__, __FILE__, __FUNCTION__); \ + PyErr_Print(); \ + PyErr_Clear(); \ + } + #define CHECKNULL(t, rc) \ (rc != NULL ? rc : YE(t, __LINE__, __FILE__, __FUNCTION__)) #define AOK(rc, err) \ @@ -164,6 +188,8 @@ static inline PyObject *atom_to_python_string(term_t t) { YEM(#rc, __LINE__, __FILE__, __FUNCTION__); \ } + +extern PyObject *YED1(PyObject *f, PyObject *a, int line, const char *file, const char *code); extern PyObject *YE(term_t , int line, const char *file, const char *code); extern PyObject *YEC(PyObject *c,PyObject *a ,PyObject *d , int line, const char *file, const char *code); extern void YEM(const char *ex, int line, const char *file, const char *code); diff --git a/packages/python/pybips.c b/packages/python/pybips.c index 6719929c4..01ef55862 100644 --- a/packages/python/pybips.c +++ b/packages/python/pybips.c @@ -987,8 +987,7 @@ PyObject *compound_to_pyeval(term_t t, PyObject *context, bool cvt) { } if (PyNumber_Check(lhs) && PyNumber_Check(rhs)) return PyNumber_Add(lhs, rhs); - PyObject_Print(builtin("+"), stderr, 0); - return PyObject_CallFunctionObjArgs(builtin("+"), lhs, rhs, NULL); + return CALL_BIP2(builtin("+"), lhs, rhs); } else if (fun == FUNCTOR_sub2) { term_t targ = PL_new_term_ref(); PyObject *lhs, *rhs; @@ -1001,7 +1000,7 @@ PyObject *compound_to_pyeval(term_t t, PyObject *context, bool cvt) { rhs = term_to_python(targ, true, NULL, true); if (PyNumber_Check(rhs) && PyNumber_Check(lhs)) return PyNumber_Subtract(lhs, rhs); - return PyObject_CallFunctionObjArgs(builtin("-"), lhs, rhs, NULL); + return CALL_BIP2(builtin("-"), lhs, rhs); } else if (fun == FUNCTOR_mul2) { term_t targ = PL_new_term_ref(); PyObject *lhs, *rhs; @@ -1022,7 +1021,7 @@ PyObject *compound_to_pyeval(term_t t, PyObject *context, bool cvt) { } if (PyNumber_Check(lhs) && PyNumber_Check(rhs)) return PyNumber_Multiply(lhs, rhs); - return PyObject_CallFunctionObjArgs(builtin("*"), lhs, rhs, NULL); + return PyObject_CallFunctionObjArgs(builtin("*"), lhs, rhs); } if (!arity) { char *s = NULL; @@ -1037,7 +1036,7 @@ PyObject *compound_to_pyeval(term_t t, PyObject *context, bool cvt) { return pValue; } else { char *s = PL_atom_chars(name); - if (!strcmp(s,"t")) { + if (!strcmp(s,"t") || !strcmp(s,"tuple")) { YAP_Term tt = YAP_GetFromSlot(t), tleft; int i; PyObject *rc = PyTuple_New(arity); @@ -1069,11 +1068,17 @@ PyObject *compound_to_pyeval(term_t t, PyObject *context, bool cvt) { /* ignore (_) */ if (indict) { if (PL_get_functor(tleft, &fun) && fun == FUNCTOR_equal2) { - term_t tatt = PL_new_term_ref(); - AOK(PL_get_arg(1, tleft, tatt), NULL); - PyObject *key = term_to_python(tatt, true, NULL, true); - AOK(PL_get_arg(2, tleft, tatt), NULL); - PyObject *val = term_to_python(tatt, true, NULL, true); + Term tatt = ArgOfTerm(1,Yap_GetFromSlot(tleft)); + const char *sk; + if (IsAtomTerm(tatt)) + sk = RepAtom(AtomOfTerm(tatt))->StrOfAE; + else if (IsStringTerm(tatt)) + sk = StringOfTerm(tatt); + else + return NULL; + PyObject *key = PyUnicode_FromString(sk); + AOK(PL_get_arg(2, tleft, tleft), NULL); + PyObject *val = term_to_python(tleft, true, o, cvt); PyDict_SetItem(pyDict, key, val); } else { indict = false; @@ -1086,7 +1091,7 @@ PyObject *compound_to_pyeval(term_t t, PyObject *context, bool cvt) { if (PL_is_variable(tleft)) { pArg = Py_None; } else { - pArg = term_to_python(tleft, true, NULL, true); + pArg = term_to_python(tleft, true, o, cvt); // PyObject_Print(pArg,fdopen(2,"w"),0); if (pArg == NULL) { pArg = Py_None; @@ -1105,9 +1110,9 @@ PyObject *compound_to_pyeval(term_t t, PyObject *context, bool cvt) { PyObject *rc; if (ys && PyCallable_Check(ys)) { - // PyObject_Print(ys, stderr, 0); - // PyObject_Print(pArgs, stderr, 0); - // PyObject_Print(pyDict, stderr, 0); + PyObject_Print(ys, stderr, 0); + PyObject_Print(pArgs, stderr, 0); + PyObject_Print(pyDict, stderr, 0); // PyObject_Print(pArgs, stderr, 0); // PyObject_Print(o, stderr, 0); diff --git a/packages/python/pyio.c b/packages/python/pyio.c index 4f000c12a..1812b5774 100644 --- a/packages/python/pyio.c +++ b/packages/python/pyio.c @@ -131,11 +131,24 @@ static bool py_close(int sno) { static bool pygetLine(StreamDesc *rl_iostream, int sno) { // term_t ctk = python_acquire_GIL(); const char *myrl_line; + PyObject *user_line; StreamDesc *s = YAP_GetStreamFromId(sno); //term_t tg = python_acquire_GIL(); + if (1) { //!strcmp(RepAtom(s->name)->StrOfAE,"input")) { + // note that input may change + PyObject *pystream = PyDict_GetItemString( Py_B``, "input"); + if (pystream == NULL) { + if ((err = PyErr_Occurred())) { + PyErr_Print(); + Yap_ThrowError(SYSTEM_ERROR_GET_FAILED, YAP_MkIntTerm(sno), err); + } + } + user_line = PyObject_CallFunctionObjArgs(pystream, NULL); + } else { PyObject *readl = PyObject_GetAttrString(s->u.private_data, "readline"); - PyObject *user_inp = PyObject_CallFunction(readl, NULL); - myrl_line = PyUnicode_AsUTF8(user_inp); + user_line = PyObject_CallFunction(readl, NULL); + } + myrl_line = PyUnicode_AsUTF8(user_line); if (myrl_line == NULL) return NULL; PyObject *err; diff --git a/packages/python/pypreds.c b/packages/python/pypreds.c index e1d32c4d9..52aa94297 100644 --- a/packages/python/pypreds.c +++ b/packages/python/pypreds.c @@ -552,6 +552,27 @@ static foreign_t python_export(term_t t, term_t pl) { pyErrorAndReturn(rc); } +static bool get_mod(const char *s0) +{ + PyObject *pName; + term_t t0 = python_acquire_GIL(); +#if PY_MAJOR_VERSION < 3 + pName = PyString_FromString(s0); +#else + pName = PyUnicode_FromString(s0); +#endif + if (pName == NULL) { + python_release_GIL(t0); + } + + PyObject *pModule = PyImport_Import(pName); + + Py_XDECREF(pName); + python_release_GIL(t0); + + return pModule; +} + /** * @pred python_import(MName, Mod) * Import a python module to the YAP environment. @@ -593,6 +614,7 @@ static int python_import(term_t mname, term_t mod) { else return false; strcat(s, sn); + //get_mod(s); strcat(s, "."); } sm = t; diff --git a/packages/python/swig/yap4py/yapi.py b/packages/python/swig/yap4py/yapi.py index bb88a8463..faba19c8c 100644 --- a/packages/python/swig/yap4py/yapi.py +++ b/packages/python/swig/yap4py/yapi.py @@ -25,6 +25,7 @@ class Engine( YAPEngine ): # type: (object) -> object if not args: args = EngineArgs(**kwargs) + args.setEmbedded(True) if self_contained: yap_lib_path = dirname(__file__) args.setYapShareDir(join(yap_lib_path, "prolog")) diff --git a/packages/python/yap_kernel/yap_ipython/_version.py b/packages/python/yap_kernel/yap_ipython/_version.py new file mode 100644 index 000000000..83fc27f53 --- /dev/null +++ b/packages/python/yap_kernel/yap_ipython/_version.py @@ -0,0 +1,5 @@ +version_info = (6, 3, 4, 'dev0') +__version__ = '.'.join(map(str, version_info)) + +kernel_protocol_version_info = (5, 1) +kernel_protocol_version = '%s.%s' % kernel_protocol_version_info diff --git a/packages/python/yap_kernel/yap_ipython/prolog/jupyter.yap b/packages/python/yap_kernel/yap_ipython/prolog/jupyter.yap index b72674986..7e90f8536 100644 --- a/packages/python/yap_kernel/yap_ipython/prolog/jupyter.yap +++ b/packages/python/yap_kernel/yap_ipython/prolog/jupyter.yap @@ -92,7 +92,7 @@ blank(Text) :- close(user_output), close(user_error). streams(true) :- - open('/python/sys.stdin', read, _Input, [alias(user_input),bom(false),script(false)]), + open('/python/input', read, _Input, [alias(user_input),bom(false),script(false)]), open('/python/sys.stdout', append, _Output, [alias(user_output)]), open('/python/sys.stderr', append, _Error, [alias(user_error)]).