diff options
Diffstat (limited to 'lib/lua-repl')
42 files changed, 3755 insertions, 0 deletions
diff --git a/lib/lua-repl/.editorconfig b/lib/lua-repl/.editorconfig new file mode 100644 index 00000000..ca4cf17b --- /dev/null +++ b/lib/lua-repl/.editorconfig @@ -0,0 +1,15 @@ +root = true + +[*] +charset = utf-8 +indent_style = space +indent_size = 2 +insert_final_newline = true +trim_trailing_whitespace = true + +[{Makefile,*.makefile}] +indent_style = tab + +[*.md] +trim_trailing_whitespace = false + diff --git a/lib/lua-repl/.gitignore b/lib/lua-repl/.gitignore new file mode 100644 index 00000000..08b58b64 --- /dev/null +++ b/lib/lua-repl/.gitignore @@ -0,0 +1,3 @@ +doc/ +*.tar.gz +*.rock diff --git a/lib/lua-repl/.proverc b/lib/lua-repl/.proverc new file mode 100644 index 00000000..a5f42ae6 --- /dev/null +++ b/lib/lua-repl/.proverc @@ -0,0 +1,2 @@ +--ext .lua +--exec lua diff --git a/lib/lua-repl/.travis.yml b/lib/lua-repl/.travis.yml new file mode 100644 index 00000000..d6390739 --- /dev/null +++ b/lib/lua-repl/.travis.yml @@ -0,0 +1,31 @@ +language: generic +sudo: false + +env: + - LUA=5.1 LUAROCKS=2.3.0 + - LUA=5.1.5 LUAROCKS=2.3.0 + - LUA=5.2.0 LUAROCKS=2.3.0 + - LUA=5.2.4 LUAROCKS=2.3.0 + - LUA=5.3.0 LUAROCKS=2.3.0 + - LUA=5.3.3 LUAROCKS=2.3.0 + +cache: + apt: true + directories: + - $HOME/luas/ + +addons: + apt: + packages: + - luarocks + +before_install: + - luarocks --local install vert + +install: + - ~/.luarocks/bin/vert init --lua-version=$LUA --luarocks-version=$LUAROCKS $HOME/luas/$LUA + - source $HOME/luas/$LUA/bin/activate + - luarocks install lua-testmore + +script: + - make test diff --git a/lib/lua-repl/COPYING b/lib/lua-repl/COPYING new file mode 100644 index 00000000..959dbc98 --- /dev/null +++ b/lib/lua-repl/COPYING @@ -0,0 +1,17 @@ +Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/lib/lua-repl/Changes b/lib/lua-repl/Changes new file mode 100644 index 00000000..1ccb438b --- /dev/null +++ b/lib/lua-repl/Changes @@ -0,0 +1,71 @@ +NEXT + +0.10 Jan 14 2022 + --- Bug Fixes --- + - Fixed issue where current buffer is stuck after certain syntax errors (GH #61, thanks Justin Blanchard!) + +0.9 Oct 30 2018 + --- Bug Fixes --- + - Fixed rlwrap plugin under Lua 5.2 and greater (GH #57) + + --- Features/Enhancements --- + - Improve support for Lua 5.3 (thanks, Iqbal Ansari!) + +0.8 + Aug 23 2015 + --- Bug Fixes --- + - Use package.searchers if package.loaders is not available (thanks, Simon Cozens!) + + --- Backwards Incompatible Changes --- + - The default plugin bundle is no longer loaded if an rcfile is present. See + https://github.com/hoelzro/lua-repl/blob/0.8/README.md#removal-of-default-plugins-in-08 + for details. + +0.7 May 22 2015 + --- Features/Enhancements --- + - iffeature is implemented, thanks to Henry Kielmann! + - loadplugin now returns any values returned by the plugin function. + + --- Deprecations --- + - 0.8 will break backwards compatability due a change in rcfile handling; + please consult the README for details. + + --- Plugins --- + - we now have a filename completion plugin, thanks to Henry Kielmann! + - rlwrap functionality has been moved into a plugin. + +0.6 Oct 18 2014 + --- Bug Fixes --- + - Fix rcfile plugin for Lua 5.2 + +0.5 Oct 17 2014 + --- Features/Enhancements --- + - Lua 5.2 support (Thanks to Simon Cozens!) + +0.4 Mar 29 2013 + --- API Additions --- + - The repl object now has a VERSION property. + + --- Bug Fixes --- + - Overriding/augmenting getcontext will actually have an effect. + - Fix pretty_print with 'unsupported' types + + --- Features/Enhancements --- + - Change the example REPL's prompt to resemble the standalone interpreter's + - The example REPL now prints a welcome message + - If linenoise is not available and rlwrap is, the example REPL falls back to rlwrap + + --- Plugins --- + - Added some new plugins + - semicolon_suppress_output + +0.3 Oct 17 2012 + - Add plugins API. + - Add a bunch of plugins. + +0.2 Sep 28 2012 + - Add linenoise REPL. + - Add completion support. + +0.1 Oct 20 2011 + Initial release. Basic REPL functionality. diff --git a/lib/lua-repl/IDEAS.md b/lib/lua-repl/IDEAS.md new file mode 100644 index 00000000..8b7eba24 --- /dev/null +++ b/lib/lua-repl/IDEAS.md @@ -0,0 +1,43 @@ + * plugins + * replace /^=/ with 'return' + * handle locals + * override debug.debug + * supple (http://cgit.gitano.org.uk/supple.git) + * handle locals (debug.sethook?) + * debug.sethook, catch return of our chunk and grab its locals + * rewrite source code/bytecode before evaluation + * custom interpreter patch to "pcall and get bindings" + * custom module that dips into internals to "pcall and get bindings" + * some sort of debugger? + * don't contaminate globals + * tab completion (\_\_complete metamethod) + * "safe" evaluation (don't allow calling of C functions, except for those in a whitelist?) + * displaystack instead of displayerror(err)? (should xpcall return false, stack\_table?) + * visual REPL (like Factor; being able to print multi-colored/multi-sized text, images, etc) + * syntax highlighting + * paren/brace matching? + * snippets? + * code navigation (go to definition?) + * repls that "attach" to different objects (ie. inspect a single object; self is that object. completions happen against that object?) + * browsable/searchable REPL history + * not entirely sure what I mean here... + * safe termination of evaluated code (if I Control-C during an evaluation) + * store stdout/stderr output in a variable somewhere? + * persistence (pluto-based image) + +hooks +===== + + * what to do when we encounter an incomplete Lua fragment + * processing a line + * something for debug.debug... + +Implementations +=============== + + * Console + * GUI + * Web + * IRC + * safety hooks + * Awesome diff --git a/lib/lua-repl/Makefile b/lib/lua-repl/Makefile new file mode 100644 index 00000000..a092d939 --- /dev/null +++ b/lib/lua-repl/Makefile @@ -0,0 +1,14 @@ +LUA_FILES=$(shell find repl -type f -name '*.lua') +.PHONY: doc install + +doc: + luadoc -d doc $(LUA_FILES) + +install: + # TODO + +test: + LUA_INIT='' LUA_PATH=';;$(LUA_PATH);?.lua;?/init.lua;t/lib/?.lua' prove + +clean: + rm -rf doc/ diff --git a/lib/lua-repl/README.md b/lib/lua-repl/README.md new file mode 100644 index 00000000..58f128b0 --- /dev/null +++ b/lib/lua-repl/README.md @@ -0,0 +1,102 @@ +# REPL.lua - a reusable Lua REPL written in Lua, and an alternative to /usr/bin/lua + +This project has two uses: + + - An alternative to the standalone interpreter included with Lua, one that supports + things like plugins, tab completion, and automatic insertion of `return` in front + of expressions. + + - A REPL library you may embed in your application, to provide all of the niceties + of the standalone interpreter included with Lua and then some. + +Many software projects have made the choice to embed Lua in their projects to +allow their users some extra flexibility. Some of these projects would also +like to provide a Lua REPL in their programs for debugging or rapid development. +Most Lua programmers are familiar with the standalone Lua interpreter as a Lua REPL; +however, it is bound to the command line. Until now, Lua programmers would have to +implement their own REPL from scratch if they wanted to include one in their programs. +This project aims to provide a REPL implemented in pure Lua that almost any project can +make use of. + +This library also includes an example application (rep.lua), which serves as an alternative +to the standalone interpreter included with Lua. If the lua-linenoise library is installed, +it uses linenoise for history and tab completion; otherwise, it tries to use rlwrap for +basic line editing. If you would like the arrow keys to work as expected rather than printing +things like `^[[A`, please install the lua-linenoise library or the rlwrap program. + +# Project Goals + + * Provide REPL logic to Lua programs that include this module. + + * Be extensible through polymorphism and plugins. + + * Abstract away I/O, so you can run this REPL on the command line or in your own event loop and expect the same behavior. + +# Building + + * You need Luadoc (http://keplerproject.github.com/luadoc/) installed to build the documentation. + + * You need Test.More (http://fperrad.github.com/lua-TestMore/testmore.html) installed to run the tests. + +# Compatibility + +The current version of the software runs on Lua 5.1, LuaJIT ?.? etc. +A port to Lua 5.2 is envisaged, but is not at this stage a priority. +Since it is written purely in Lua, it should work on any platform that +has one of those versions of Lua installed. + +XXX Check which version of LuaJIT this works with +XXX Check that it works with other Lua interpreters + +# Installation + +You can install lua-repl via LuaRocks: + + luarocks install luarepl + +You can also install it by hand by copying the `repl` +directory to a location in your `package.path`, and +copying rep.lua to somewhere in your `PATH`. + +# Recommended packages + +`rep.lua` works best if you also have `linenoise` installed, +available from https://github.com/hoelzro/lua-linenoise. +`rep.lua` will fallback to using rlwrap if you have that as well; +without either of these, you will have command editing, history, +or other features generally provided by `readline`. + +# Features + +`rep.lua` prints the results of simple expressions without requiring +a `return ` or a `= ` in front of it. If `linenoise` is installed, +it also offers persistent history and tab completion. It also offers +a number of plugins; see plugins.md for a list of plugins that come +with lua-repl. + +# Backwards Compatibility Changes + +## Removal of default plugins in 0.8 + +Lua REPL 0.8 breaks backwards compatability by disabling the loading of the +default plugins (currently `linenoise`, `rlwrap`, `history`, `completion`, and +`autoreturn`) if an rcfile is found for a user. This is so that plugins may +not be forced onto a user if they don't want them, or play tricks with their +setup (see issue #47). If you would like to continue using these plugins, please +put the following code into your `~/.rep.lua`: + +```lua +if repl.VERSION >= 0.8 then + -- default plugins + repl:loadplugin 'linenoise' + repl:loadplugin 'history' + repl:loadplugin 'completion' + repl:loadplugin 'autoreturn' +end + +-- suppress warning message +repl.quiet_default_plugins = true +``` + +As mentioned in the code snippet, `repl.quiet_default_plugins` suppresses the warning. +You can remove this after upgrading to Lua REPL 0.8. diff --git a/lib/lua-repl/RELEASE-GUIDE.md b/lib/lua-repl/RELEASE-GUIDE.md new file mode 100644 index 00000000..1efcb728 --- /dev/null +++ b/lib/lua-repl/RELEASE-GUIDE.md @@ -0,0 +1,34 @@ +# lua-repl release guide + + - [ ] Bump VERSION (in repl/init.lua, look for references to current version) + - [ ] Update Changelog + - [ ] Rename and update rockspec + - [ ] Make sure tests pass + - [ ] Push & tag latest release + - [ ] Submit rockspec to luarocks + - [ ] E-mail lua-l + - [ ] Submit lua-l gmane link to reddit + +## E-mail template for lua-l + +Hi Lua users, + +I have just released version {{VERSION}} of lua-repl, an alternative to the +standalone REPL included with Lua and a library for embedding a Lua +REPL within a Lua application. + +lua-repl provides a library for adding a Lua REPL to your Lua-powered +application. It also provides an example REPL in the form of rep.lua, +which can take the place of the standalone interpreter provided with +Lua. It has a plugin facility; plugins for things like history and tab +completion of symbols are included in the lua-repl distribution. + +{{CHANGES}} + +You can install lua-repl via Luarocks (called luarepl there), or +manually from the source [{{REFERENCE}}]. + +-Rob + +[{{REFERENCE}}] https://github.com/hoelzro/lua-repl/archive/0.8.tar.gz + diff --git a/lib/lua-repl/Roadmap.md b/lib/lua-repl/Roadmap.md new file mode 100644 index 00000000..baaa3870 --- /dev/null +++ b/lib/lua-repl/Roadmap.md @@ -0,0 +1,44 @@ +0.10 +=== + + * Process Lua command line options with rep.lua + * Verify that it works with LuaJIT, Lua 5.0, Lua 5.2, LuaJ or something + * __pretty support for pretty print plugin + * __complete support for completion plugin + * Documentation improvements + * More clearly reference PLUGINS.md from README.md + * More clearly reference rep.lua from README.md + * Make sure that autocompletion is talked up in plugins.md (and mention in readme that many default/optional behaviors are present there) + * Make sure documentation on ~/.rep.lua is clear + * Move docs into doc/ + +Future +====== + + * Plugins + * where do plugins store values (self, storage object, etc?) + * configuration + * global assignments in plugins + * we need a way to do method advice in REPL "subclasses" + * test: using advice from within ifplugin/iffeature + * luaish plugin + * moonscript plugin - compile Moonscript instead of Lua + * Steal ideas from ilua + * Variables in ilua must be declared before use + * -L is like -l, except it automatically brings it into the global NS + * require() wrapper that does this ↑ + * table display logic control, float precision control + * print\_handler (custom print logic for types) + * \_\_pretty + * global\_handler (custom lookup logic to complement strict mode) + * easily done via a plugin + * line\_handler (custom handling of lines before being processed) + * Steal ideas from luaish + * Shell commands (lines beginning with ., filename completion) + * Steal ideas from http://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print\_loop + * Steal ideas from pry, ipython, bpython, Devel::REPL, Factor REPL + * Steal ideas from https://github.com/tpope/vim-foreplay + * Async implementation + * GTK implementation + * IRC bot implementation + * Awesome library diff --git a/lib/lua-repl/dev/RELEASE-MESSAGE b/lib/lua-repl/dev/RELEASE-MESSAGE new file mode 100644 index 00000000..0fdbdf34 --- /dev/null +++ b/lib/lua-repl/dev/RELEASE-MESSAGE @@ -0,0 +1,21 @@ +To: <lua-l@lists.lua.org> +Subject: [ANN] lua-repl $VERSION + +Hi everyone, + +I'm happy to announce a new version of lua-repl! + +For those of you who aren't aware of it, lua-repl is a library to make +it easy to embed a REPL similar to the standalone interpreter in your +Lua application. It also comes with a suite of plugins for enhancing +itself, as well as a "demo" console REPL that may be used as an +alternative to the standalone REPL (named rep.lua). + +$CHANGE_SUMMARY + +The source for lua-repl is located on Github: +https://github.com/hoelzro/lua-repl. The release tarball is here: +https://github.com/hoelzro/lua-repl/archive/$VERSION.tar.gz + +Thanks, +Rob diff --git a/lib/lua-repl/luarepl-0.10-1.rockspec b/lib/lua-repl/luarepl-0.10-1.rockspec new file mode 100644 index 00000000..4b3401a5 --- /dev/null +++ b/lib/lua-repl/luarepl-0.10-1.rockspec @@ -0,0 +1,38 @@ +package = 'luarepl' +version = '0.10-1' +source = { + url = 'https://github.com/hoelzro/lua-repl/archive/0.10.tar.gz', + dir = 'lua-repl-0.10', +} +description = { + summary = 'A reusable REPL component for Lua, written in Lua', + homepage = 'https://github.com/hoelzro/lua-repl', + license = 'MIT/X11', +} +dependencies = { + 'lua >= 5.1' +} +build = { + type = 'builtin', + modules = { + ['repl'] = 'repl/init.lua', + ['repl.utils'] = 'repl/utils.lua', + ['repl.sync'] = 'repl/sync.lua', + ['repl.compat'] = 'repl/compat.lua', + ['repl.console'] = 'repl/console.lua', + ['repl.plugins.autoreturn'] = 'repl/plugins/autoreturn.lua', + ['repl.plugins.completion'] = 'repl/plugins/completion.lua', + ['repl.plugins.example'] = 'repl/plugins/example.lua', + ['repl.plugins.history'] = 'repl/plugins/history.lua', + ['repl.plugins.keep_last_eval'] = 'repl/plugins/keep_last_eval.lua', + ['repl.plugins.linenoise'] = 'repl/plugins/linenoise.lua', + ['repl.plugins.pretty_print'] = 'repl/plugins/pretty_print.lua', + ['repl.plugins.rcfile'] = 'repl/plugins/rcfile.lua', + ['repl.plugins.semicolon_suppress_output'] = 'repl/plugins/semicolon_suppress_output.lua', + ['repl.plugins.filename_completion'] = 'repl/plugins/filename_completion.lua', + ['repl.plugins.rlwrap'] = 'repl/plugins/rlwrap.lua', + }, + install = { + bin = { 'rep.lua' }, + } +} diff --git a/lib/lua-repl/plugins.md b/lib/lua-repl/plugins.md new file mode 100644 index 00000000..2a3591b4 --- /dev/null +++ b/lib/lua-repl/plugins.md @@ -0,0 +1,285 @@ +# Plugins + +As of version 0.3, lua-repl supports a plugin mechanism. For an example, please download the source code for +lua-repl and look at `repl/plugins/example.lua`. + +# Available Plugins + +lua-repl 0.3 ships with several plugins. If you use the example script `rep.lua`, some of them are loaded automatically; +these are marked with an asterisk. + +## autoreturn (\*) + +Automatically returns the the results of the evaluated expression. So instead of having to type 'return 3', you may +simply type '3'. + +## completion (\*) + +Provides completion facilities via the 'completion' feature. Other plugins may hook into this to provide tab completion. + +## example + +Simply an example plugin. + +## history (\*) + +Provides history facilities (and the 'history' feature), storing each line entered as an individual history entry, +and persisting the history in `$HOME/.rep.lua.history`. Other plugins may hook into this. + +## keep\_last\_eval + +Retains the results of the previously evaluated expression in global variables. The first result is stored in `_1`, the +second in `_2`, etc. For brevity's sake, the first result is also stored in `_`. + +## linenoise (\*) + +Hooks into the linenoise library. Allows the use of tab completion and history. + +## pretty\_print + +'Pretty prints' return values. Tables are printed in expanded form. Colors are provided if lua-term is installed. + +## rcfile (\*) + +Loads Lua code in `$HOME/.rep.lua` if the file exists. The repl object is provided to the file in a variable named `repl`, so +users may load plugins of their choosing. + +## semicolon_suppress_output + +Suppresses automatic printing of an expression's result if the expression ends in a semicolon. + +# Creating a Plugin + +If you would like to create your own plugin, it must be in a file under `repl/plugins/` in your `package.path`. + +# Plugin Objects + +When a plugin is loaded, it is provided with five special objects that are used to affect the behavior of the REPL +object loading the plugin. + +## repl + +The `repl` object is a proxy object for the REPL object loading the plugin; you can invoke methods on it, create methods on +it, set properties on it, etc. However, if you try to create a method on the `repl` object that already exists, an error +will occur. This is to keep plugin authors from stepping on each others' toes. + +## before + +The `before` object is another proxy object from the plugin environment. If you add methods to the `before` object, the original +method remains intact; however, the method you added will be called before the original. For example, if you wanted to print +"I got some results!" before you display them on the command line, your plugin could do this: + +```lua +function before:displayresults(results) + print 'I got some results!' +end +``` + +This is called *advice*, and is stolen from Moose, an object system for the Perl programming language. + +When you apply multiple pieces of advice via `before`, they are called in last-in-first-out order: + +```lua +function before:method() + print 'Second!' +end + +function before:method() + print 'First!' +end +``` + +`before` also receives all of the parameters to the original method. If they are tables, userdata, etc, you may alter them, +which can alter the behavior of the original method, for better or for worse. + +If the method you are applying advice to does not exist on the current REPL object, an error will occur. This way, developers +can find out about API changes quickly, albeit noisily. + +## after + +The `after` object is another proxy object that attaches advice to the loading REPL object. As you can likely tell from its name, +advice applied via the `after` object occurs after the original method. Advice applied via after is called in first-in-first-out order: + +```lua +function after:method() + print 'First!' +end + +function after:method() + print 'Second!' +end +``` + +Like `before`, if you try applying advice to a method that doesn't exist, an error will occur. Also like `before`, after advice receives +all of the parameters passed to the original method. + +## around + +The `around` object is another advice object, but it works a little differently than `before` or `after`. `around` replaces the current +method will the advice, and like `before` and `after`, receives all of the parameters that would be passed to the original. However, +`around` also receives an additional parameter immediately before the parameters: the original method. This way, you can invoke +the method's original functionality if needed. For example: + +```lua +function around:displayresults(orig, results) + print "I'm displaying some results!" + orig(self, results) -- don't forget self! + print "Now I'm done!" +end +``` + +Like the other advice objects, you can't apply advice to a method that doesn't exist. Also, be warned: the `around` advice does nothing +to make sure that the parameters are passed to the original function, and it doesn't make sure that the return values from the original +function are returned. You need to do that yourself. + +## override + +The `override` object isn't really an advice object; adding methods to it will replace the methods in the REPL object itself. However, +it will fail if that method does not already exist. The rule of thumb is if you want to add new methods to the REPL object, use +`repl`; if you want to completely override an existing method, use `override`. Keep in mind this will blow away all advice applied to +a method from other plugins; use with caution! + +# Features + +Sometimes, different plugins will want to provide a method, but implemented in a different way. For example, the completion plugin +included with lua-repl implements a tab completion method; however, if you are embedding lua-repl into your own environment, you may +have a more sophisicated way to provide completions. Other plugins (like the linenoise plugin) may want to hook into the completion +feature itself, without being tied to a particular implementation. So plugins may advertise a list of *features* that they provide, +so that they can develop loose relationships between one another. To advertise features for your plugin, simply set the features variable: + +```lua +features = 'completion' -- make sure you're not setting a local! +``` + +If you wish you provide multiple features, simply use a table: + +```lua +features = { 'completion', 'something_else' } +``` + +Obviously, plugins providing a feature need to agree on a standard interface of methods that they provide. No framework is in place for this as +of yet. + +REPL objects may provide features as well; for example, `repl.console` provides the 'console' feature. You can use this to make sure your +plugins are only loaded in certain environments. + +# REPL Methods + +Now that you know how to affect the behavior of lua-repl with plugins, let's go over the methods you may advise/override, or call yourself from +within your advised/overridden methods. Please keep in mind that since lua-repl is still a young project, this API is subject to change. + +## repl:getprompt(level) + +Returns the prompt string displayed for the given prompt level, which is either 1 or 2. +1 signifies that the REPL is not in a multi-line expression (like a for loop); 2 signifies +otherwise. + +## repl:prompt(level) + +Actually displays the prompt for the given level. You more likely want to deal with +getprompt or showprompt. + +## repl:name() + +Returns the name of the REPL, used when compiling the chunks for evaluation. + +## repl:traceback(err) + +Returns a stack trace, prefixed by the given error message. + +## repl:detectcontinue(err) + +Detects whether or not the given error message means that more input is needed for a complete +chunk. You probably shouldn't touch this. + +## repl:compilechunk(code) + +Compiles the given chunk of code, returning a function, or a falsy value and an error message. + +## repl:getcontext() + +Returns the function environment that the REPL evaluates code in. + +## repl:handleline(line) + +Handles a line of input, returning the prompt level (1 or 2). Note that if this method is +called, an evaluation does not necessarily occur. + +## repl:showprompt(prompt) + +Displays the given prompt. + +## repl:displayresults(results) + +Displays the results from an evaluation. `results` is a table with the individual values in +the integer indices of the table, with the `n` key containing the number of values in the table. + +## repl:displayerror(err) + +Displays an error from an evaluation. + +## repl:hasplugin(plugin) + +Returns `true` if the given plugin has been loaded, `false` otherwise. + +## repl:hasfeature(feature) + +Returns `true` if the given feature has been loaded, `false` otherwise. + +## repl:requirefeature(feature) + +If the given feature has been loaded, do nothing. Otherwise, raise an error. + +## repl:ifplugin(plugin, action) + +If the given plugin has been loaded, call `action`. Otherwise, if the plugin +is ever loaded in the future, call `action` after that loading occurs. + +## repl:iffeature(feature, action) + +If the given feature has been loaded, call `action`. Otherwise, if the feature +is ever loaded in the future, call `action` after that loading occurs. + +## repl:loadplugin(plugin) + +Loads the given plugin. If the plugin returns a value, that value is returned. + +## repl:shutdown() + +Called when the REPL is exited. Don't call this yourself! + +## repl:lines() -- repl.sync only + +Returns an iterator that yields a line of input per invocation. + +# The Future + +This is the first release of lua-repl with plugins. The future will bring various +refinements to the plugin interface, along with the following planned features: + +## Feature Interfaces + +Earlier I mentioned that features have a sort of "gentlemen's aggreement" on what +methods they will provide. It would be nice if the plugin system had a way of +enforcing that. + +## Attribute Storage + +Currently, if a plugin wants to store some information between method calls, it needs +to store it on the REPL object (`self`) and hope no other plugins (or REPL clone) will +use the same name. Plugin-specific storage is a high priority. + +## Configuration + +Currently, plugins don't have any sort of configuration mechanism. I plan to change that. + +## Library Plugins + +Some plugins may want to leverage functionality of others without loading those others into +the REPL itself. I call these *library plugins*. + +## Better Diagnostics + +If you try to add a method that has already been added, or provide a feature that has already been +provided, you receive no information on which plugin provided the method or feature in question. +It would be nice to know. diff --git a/lib/lua-repl/rep.lua b/lib/lua-repl/rep.lua new file mode 100755 index 00000000..029c3192 --- /dev/null +++ b/lib/lua-repl/rep.lua @@ -0,0 +1,41 @@ +#!/usr/bin/env lua + +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +-- Not as cool a name as re.pl, but I tried. + +local repl = require 'repl.console' +local rcfile_loaded = repl:loadplugin 'rcfile' + +if not rcfile_loaded then + local has_linenoise = pcall(require, 'linenoise') + + if has_linenoise then + repl:loadplugin 'linenoise' + else + pcall(repl.loadplugin, repl, 'rlwrap') + end + + repl:loadplugin 'history' + repl:loadplugin 'completion' + repl:loadplugin 'autoreturn' +end + +print('Lua REPL ' .. tostring(repl.VERSION)) +repl:run() diff --git a/lib/lua-repl/repl/compat.lua b/lib/lua-repl/repl/compat.lua new file mode 100644 index 00000000..fd47748c --- /dev/null +++ b/lib/lua-repl/repl/compat.lua @@ -0,0 +1,30 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +return { + -- unpack was moved to table.unpack on Lua version 5.2 + -- See https://www.lua.org/manual/5.2/manual.html#8 + unpack = unpack or table.unpack, + -- loadstring was deprecated in favor of load, which was updated + -- to handle string arguments + loadstring = loadstring or load, + -- package.loaders was renamed package.searchers in Lua 5.2 + package = { + searchers = package.loaders or package.searchers + } +} diff --git a/lib/lua-repl/repl/console.lua b/lib/lua-repl/repl/console.lua new file mode 100644 index 00000000..154d0372 --- /dev/null +++ b/lib/lua-repl/repl/console.lua @@ -0,0 +1,57 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +-- @class repl.console +--- This module implements a command line-based REPL, +--- similar to the standalone Lua interpreter. + +local sync_repl = require 'repl.sync' +local compat = require 'repl.compat' +local console_repl = sync_repl:clone() +local stdout = io.stdout +local stdin = io.stdin +local print = print +local unpack = unpack + +-- @see repl:showprompt(prompt) +function console_repl:showprompt(prompt) + stdout:write(prompt .. ' ') +end + +-- @see repl.sync:lines() +function console_repl:lines() + return stdin:lines() +end + +-- @see repl:displayresults(results) +function console_repl:displayresults(results) + if results.n == 0 then + return + end + + print(compat.unpack(results, 1, results.n)) +end + +-- @see repl:displayerror(err) +function console_repl:displayerror(err) + print(err) +end + +console_repl._features.console = true + +return console_repl diff --git a/lib/lua-repl/repl/init.lua b/lib/lua-repl/repl/init.lua new file mode 100644 index 00000000..b5499f59 --- /dev/null +++ b/lib/lua-repl/repl/init.lua @@ -0,0 +1,416 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +-- @class repl +--- This module implements the core functionality of a REPL. + +local plugins_lookup_meta = { __mode = 'k' } + +local repl = { _buffer = '', _plugins = setmetatable({}, plugins_lookup_meta), _features = {}, _ifplugin = {}, _iffeature = {}, VERSION = 0.10 } +local compat = require 'repl.compat' +local select = select +local dtraceback = debug.traceback +local setmetatable = setmetatable +local sformat = string.format +local smatch = string.match +local error = error +local setfenv = require('repl.utils').setfenv + +local function gather_results(success, ...) + local n = select('#', ...) + return success, { n = n, ... } +end + +local function tcopy(t, copy) + copy = copy or {} + + for k, v in pairs(t) do + copy[k] = v + end + + return copy +end + +--- Returns the prompt for a given level. +-- @param level The prompt level. Either 1 or 2. +function repl:getprompt(level) + return level == 1 and '>' or '>>' +end + +--- Displays a prompt for the given prompt level. +-- @param level The prompt level. Either 1 or 2. +function repl:prompt(level) + self:showprompt(self:getprompt(level)) +end + +--- Returns the name of the REPL. For usage in chunk compilation. +-- @return The REPL's name. +-- @see load +function repl:name() + return 'REPL' +end + +--- Gets a traceback for an error. +-- @param ... All of the stuff that xpcall passes to error functions. +-- @see xpcall +-- @return A stack trace. The default implementation returns a simple string-based trace. +function repl:traceback(...) + return dtraceback(...) +end + +--- Uses the compilation error to determine whether or not further input +--- is pending after the last line. You shouldn't have to override this +--- unless you use an implementation of Lua that varies in its error +--- messages. +-- @param err The compilation error from Lua. +-- @return Whether or not the input should continue after this line. +function repl:detectcontinue(err) + return smatch(err, "'<eof>'$") or smatch(err, "<eof>$") +end + +function repl:compilechunk(chunk) + return compat.loadstring(chunk, self:name()) +end + +--- Evaluates a line of input, and displays return value(s). +-- @param line The line to evaluate +-- @return The prompt level (1 or 2) +function repl:handleline(line) + local chunk = self._buffer .. line + local f, err = self:compilechunk(chunk) + + if f then + self._buffer = '' + + setfenv(f, self:getcontext()) + local success, results = gather_results(xpcall(f, function(...) return self:traceback(...) end)) + if success then + self:displayresults(results) + else + self:displayerror(results[1]) + end + else + if self:detectcontinue(err) then + self._buffer = chunk .. '\n' + return 2 + else + self:displayerror(err) + self._buffer = '' + end + end + + return 1 +end + +--- Creates a new REPL object, so you can override methods without fear. +-- @return A REPL clone. +function repl:clone() + local plugins_copy = tcopy(self._plugins, setmetatable({}, plugins_lookup_meta)) + local features_copy = tcopy(self._features) + local ifplugin_copy = {} + local iffeature_copy = {} + + for k, v in pairs(self._ifplugin) do + ifplugin_copy[k] = tcopy(v) + end + + for k, v in pairs(self._iffeature) do + iffeature_copy[k] = tcopy(v) + end + + return setmetatable({ + _buffer = '', + _plugins = plugins_copy, + _features = features_copy, + _ifplugin = ifplugin_copy, + _iffeature = iffeature_copy, + }, { __index = self }) +end + +--- Displays the given prompt to the user. Must be overriden. +-- @param prompt The prompt to display. +function repl:showprompt(prompt) + error 'You must implement the showprompt method' +end + +--- Displays the results from evaluate(). Must be overriden. +-- @param results The results to display. The results are a table, with the integer keys containing the results, and the 'n' key containing the highest integer key. + +function repl:displayresults(results) + error 'You must implement the displayresults method' +end + +--- Displays errors from evaluate(). Must be overriden. +-- @param err The error value returned from repl:traceback(). +-- @see repl:traceback +function repl:displayerror(err) + error 'You must implement the displayerror method' +end + +--- Checks whether this REPL object has loaded the given plugin. +-- @param plugin The plugin that the REPL may have loaded. +function repl:hasplugin(plugin) + return self._plugins[plugin] +end + +function repl:hasfeature(feature) + return self._features[feature] +end + +function repl:requirefeature(feature) + if not self:hasfeature(feature) then + error(sformat('required feature %q not present', feature), 2) + end +end + +function repl:ifplugin(plugin, action) + if self:hasplugin(plugin) then + action() + else + local pending_actions = self._ifplugin[plugin] + + if not pending_actions then + pending_actions = {} + self._ifplugin[plugin] = pending_actions + end + + pending_actions[#pending_actions + 1] = action + end +end + +--- If the given feature has been loaded, call `action`. Otherwise, if the +-- feature is ever loaded in the future, call `action` after that loading occurs. +function repl:iffeature(feature, action) + if self:hasfeature(feature) then + action() + else + local pending_features = self._iffeature[feature] + + if not pending_features then + pending_features = {} + self._iffeature[feature] = pending_features + end + + pending_features[#pending_features + 1] = action + end +end + +local function setup_before(repl) + local mt = {} + + function mt:__newindex(key, value) + if type(value) ~= 'function' then + error(tostring(value) .. " is not a function", 2) + end + + local old_value = repl[key] + + if old_value == nil then + error(sformat("The '%s' method does not exist", key), 2) + end + + repl[key] = function(...) + value(...) + return old_value(...) + end + end + + return setmetatable({}, mt) +end + +local function setup_after(repl) + local mt = {} + + function mt:__newindex(key, value) + if type(value) ~= 'function' then + error(tostring(value) .. " is not a function", 2) + end + + local old_value = repl[key] + + if old_value == nil then + error(sformat("The '%s' method does not exist", key), 2) + end + + repl[key] = function(...) + local _, results = gather_results(true, old_value(...)) + value(...) + return compat.unpack(results, 1, results.n) + end + end + + return setmetatable({}, mt) +end + +local function setup_around(repl) + local mt = {} + + function mt:__newindex(key, value) + if type(value) ~= 'function' then + error(tostring(value) .. " is not a function", 2) + end + + local old_value = repl[key] + + if old_value == nil then + error(sformat("The '%s' method does not exist", key), 2) + end + + repl[key] = function(self, ...) + return value(self, old_value, ...) + end + end + + return setmetatable({}, mt) +end + +local function setup_override(repl) + local mt = {} + + function mt:__newindex(key, value) + if type(value) ~= 'function' then + error(tostring(value) .. " is not a function", 2) + end + + local old_value = repl[key] + + if old_value == nil then + error(sformat("The '%s' method does not exist", key), 2) + end + + repl[key] = value + end + + return setmetatable({}, mt) +end + +local function setup_repl(repl) + local mt = {} + + function mt:__newindex(key, value) + local old_value = repl[key] + + if old_value ~= nil then + error(sformat("The '%s' method already exists", key), 2) + end + + repl[key] = value + end + + function mt:__index(key) + local value = repl[key] + + if type(value) == 'function' then + -- XXX cache this? + return function(_, ...) + return value(repl, ...) + end + end + + return value + end + + return setmetatable({}, mt) +end + +-- TODO use lua-procure for this (eventually) +local function findchunk(name) + for _, loader in pairs(compat.package.searchers) do + local chunk = loader(name) + + if type(chunk) == 'function' then + return chunk + end + end + + error('unable to locate plugin', 3) +end + +function repl:loadplugin(chunk) + if self:hasplugin(chunk) then + error(sformat('plugin %q has already been loaded', tostring(chunk)), 2) + end + self._plugins[chunk] = true + + local plugin_actions = self._ifplugin[chunk] + self._ifplugin[chunk] = nil + + if type(chunk) == 'string' then + chunk = findchunk('repl.plugins.' .. chunk) + end + + local plugin_env = { + repl = setup_repl(self), + before = setup_before(self), + after = setup_after(self), + around = setup_around(self), + override = setup_override(self), + init = function() end, + } + + local function ro_globals(_, key, _) + error(sformat('global environment is read-only (key = %q)', key), 2) + end + + plugin_env._G = plugin_env + plugin_env.features = {} + setmetatable(plugin_env, { __index = _G, __newindex = ro_globals }) + + setfenv(chunk, plugin_env) + local _, results = gather_results(nil, chunk()) + + local features = plugin_env.features or {} + + if type(features) == 'string' then + features = { features } + end + + for _, feature in ipairs(features) do + if self._features[feature] then + error(sformat('feature %q already present', feature), 2) + end + + self._features[feature] = true + + local feature_actions = self._iffeature[feature] + self._iffeature[feature] = nil + if feature_actions then + for _, action in ipairs(feature_actions) do + action() + end + end + end + + if plugin_actions then + for _, action in ipairs(plugin_actions) do + action() + end + end + + return compat.unpack(results, 1, results.n) +end + +-- XXX how to guarantee this gets called? +function repl:shutdown() +end + +function repl:getcontext() + return _G +end + +return repl diff --git a/lib/lua-repl/repl/plugins/autoreturn.lua b/lib/lua-repl/repl/plugins/autoreturn.lua new file mode 100644 index 00000000..a0e15eab --- /dev/null +++ b/lib/lua-repl/repl/plugins/autoreturn.lua @@ -0,0 +1,29 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +-- A plugin that causes the REPL to automatically return evaluation results + +function around:compilechunk(orig, chunk) + local f, err = orig(self, 'return ' .. chunk) + + if not f then + f, err = orig(self, chunk) + end + + return f, err +end diff --git a/lib/lua-repl/repl/plugins/completion.lua b/lib/lua-repl/repl/plugins/completion.lua new file mode 100644 index 00000000..938c7439 --- /dev/null +++ b/lib/lua-repl/repl/plugins/completion.lua @@ -0,0 +1,192 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +local utils = require 'repl.utils' +local getmetatable = getmetatable +local pairs = pairs +local sfind = string.find +local sgmatch = string.gmatch +local smatch = string.match +local ssub = string.sub +local tconcat = table.concat +local tsort = table.sort +local type = type + +local function isindexable(value) + if type(value) == 'table' then + return true + end + + local mt = getmetatable(value) + + return mt and mt.__index +end + +local function getcompletions(t) + local union = {} + + while isindexable(t) do + if type(t) == 'table' then + -- XXX what about the pairs metamethod in 5.2? + -- either we don't care, we implement a __pairs-friendly + -- pairs for 5.1, or implement a 'rawpairs' for 5.2 + for k, v in pairs(t) do + if union[k] == nil then + union[k] = v + end + end + end + + local mt = getmetatable(t) + t = mt and mt.__index or nil + end + + return pairs(union) +end + +local function split_ns(expr) + if expr == '' then + return { '' } + end + + local pieces = {} + + -- XXX method calls too (option?) + for m in sgmatch(expr, '[^.]+') do + pieces[#pieces + 1] = m + end + + -- logic for determining whether to pad the matches with the empty + -- string (ugly) + if ssub(expr, -1) == '.' then + pieces[#pieces + 1] = '' + end + + return pieces +end + +local function determine_ns(expr) + local ns = _G -- XXX what if the REPL lives in a special context? (option?) + local pieces = split_ns(expr) + + for index = 1, #pieces - 1 do + local key = pieces[index] + -- XXX rawget? or regular access? (option?) + ns = ns[key] + + if not isindexable(ns) then + return {}, '', '' + end + end + + expr = pieces[#pieces] + + local prefix = '' + + if #pieces > 1 then + prefix = tconcat(pieces, '.', 1, #pieces - 1) .. '.' + end + + local last_piece = pieces[#pieces] + + local before, after = smatch(last_piece, '(.*):(.*)') + + if before then + ns = ns[before] -- XXX rawget + prefix = prefix .. before .. ':' + expr = after + end + + return ns, prefix, expr +end + +local isidentifierchar + +do + local ident_chars_set = {} + -- XXX I think this can be done with isalpha in C... + local ident_chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.:_0123456789' + + for i = 1, #ident_chars do + local char = ssub(ident_chars, i, i) + ident_chars_set[char] = true + end + + function isidentifierchar(char) + return ident_chars_set[char] + end +end + +local function extract_innermost_expr(expr) + local index = #expr + + while index > 0 do + local char = ssub(expr, index, index) + if isidentifierchar(char) then + index = index - 1 + else + break + end + end + + index = index + 1 + + return ssub(expr, 1, index - 1), ssub(expr, index) +end + +-- XXX is this logic (namely, returning the entire line) too specific to +-- linenoise? +function repl:complete(expr, callback) + if utils.ends_in_unfinished_string(expr) then + return + end + + local ns, prefix, path + + prefix, expr = extract_innermost_expr(expr) + + ns, path, expr = determine_ns(expr) + + prefix = prefix .. path + + local completions = {} + + for k, v in getcompletions(ns) do + if sfind(k, expr, 1, true) == 1 then + local suffix = '' + local type = type(v) + + -- XXX this should be optional + if type == 'function' then + suffix = '(' + elseif type == 'table' then + suffix = '.' + end + + completions[#completions + 1] = prefix .. k .. suffix + end + end + + tsort(completions) + + for _, completion in ipairs(completions) do + callback(completion) + end +end + +features = 'completion' diff --git a/lib/lua-repl/repl/plugins/example.lua b/lib/lua-repl/repl/plugins/example.lua new file mode 100644 index 00000000..d55fd076 --- /dev/null +++ b/lib/lua-repl/repl/plugins/example.lua @@ -0,0 +1,41 @@ +-- Example plugin that demonstrates the objects available to a +-- plugin, as well as the methods that a plugin should make use +-- of + +-- Adding methods and properties to the repl object adds them to +-- the REPL object loading the plugin. If such a method or property +-- already exists, the current plugin will fail to load. +function repl:newmethod(...) +end + +-- Adding methods to the before object causes them to be called +-- before the actual method itself. If the method being added +-- (in this case displayresults) does not exist on the REPL object +-- loading this plugin, the current plugin will fail to load. +function before:displayresults(results) +end + +-- Adding methods to the after object causes them to be called +-- after the actual method itself. If the method being added +-- (in this case displayresults) does not exist on the REPL object +-- loading this plugin, the current plugin will fail to load. +function after:displayresults(results) +end + +-- Adding methods to the around object causes them to be called +-- instead of the original method of the same name. The new +-- method receives all of the arguments that the original would, +-- except it also receives the original method as the first argument. +-- This way, the new method may invoke the original as it pleases. +-- If the method being added (in this case displayresults) does not exist on +-- the REPL object loading this plugin, the current plugin will fail to load. +function around:evalute(orig, chunk) +end + +-- Adding methods to the override object causes them to be called +-- instead of the original method of the same name. If the method being added +-- (in this case displayresults) does not exist on the REPL object loading this +-- plugin, the current plugin will fail to load. +function override:name() + return 'Plugin!' +end diff --git a/lib/lua-repl/repl/plugins/filename_completion.lua b/lib/lua-repl/repl/plugins/filename_completion.lua new file mode 100644 index 00000000..c16729f3 --- /dev/null +++ b/lib/lua-repl/repl/plugins/filename_completion.lua @@ -0,0 +1,63 @@ +local utils = require 'repl.utils' +local lfs = require 'lfs' + +repl:requirefeature 'completion' + +local function guess_directory_separator(file_name) + return file_name:match('/') or + file_name:match('\\') or + '/' +end + +local function split_parent_directory(file_name) + local parent_directory, directory_entry = + file_name:match('^(.+)[\\/](.+)$') + if not parent_directory then + parent_directory = '.' + directory_entry = file_name + end + return parent_directory, directory_entry +end + +local function is_ignored_directory_entry(entry) + return entry == '.' or + entry == '..' +end + +local function replace_end_of_string(str, suffix, replacement) + assert(str:sub(-#suffix) == suffix) + return str:sub(1, -(#suffix+1)) .. replacement +end + +local function complete_file_name(file_name, expr, callback) + local directory, partial_entry = split_parent_directory(file_name) + for entry in lfs.dir(directory) do + if not is_ignored_directory_entry(entry) and + entry:find(partial_entry, 1, true) == 1 then + callback(replace_end_of_string(expr, partial_entry, entry)) + end + end +end + +local function complete_directory(directory, expr, callback) + for entry in lfs.dir(directory) do + if not is_ignored_directory_entry(entry) then + callback(expr..entry) + end + end +end + +function after:complete(expr, callback) + if utils.ends_in_unfinished_string(expr) then + local file_name = expr:match('[%w@/\\.-_+#$%%{}[%]!~ ]+$') + if file_name then + if file_name:find('[/\\]$') then + complete_directory(file_name, expr, callback) + else + complete_file_name(file_name, expr, callback) + end + else + complete_directory('.', expr, callback) + end + end +end diff --git a/lib/lua-repl/repl/plugins/history.lua b/lib/lua-repl/repl/plugins/history.lua new file mode 100644 index 00000000..6330dbd2 --- /dev/null +++ b/lib/lua-repl/repl/plugins/history.lua @@ -0,0 +1,60 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +local history_file + +local function invokecallback(self, name, ...) + if not self._history_callbacks then + return + end + + local impl = self._history_callbacks[name] + return impl(...) +end + +local function init() + if os.getenv 'HOME' then + history_file = os.getenv('HOME') .. '/.rep.lua.history' + end +end + +-- XXX I don't know if this callback setup way +-- is the best way to go about this (in fact +-- I'm pretty sure it isn't), but I just need +-- something that works right now. +function repl:setuphistorycallbacks(callbacks) + self._history_callbacks = callbacks + + if history_file then + invokecallback(self, 'load', history_file) + end +end + +function after:handleline(line) + invokecallback(self, 'addline', line) +end + +function before:shutdown() + if history_file then + invokecallback(self, 'save', history_file) + end +end + +features = 'history' + +init() diff --git a/lib/lua-repl/repl/plugins/keep_last_eval.lua b/lib/lua-repl/repl/plugins/keep_last_eval.lua new file mode 100644 index 00000000..01a77946 --- /dev/null +++ b/lib/lua-repl/repl/plugins/keep_last_eval.lua @@ -0,0 +1,43 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +-- A plugin that stores the results of the last evaluation in _G._ + +local tostring = tostring + +function before:displayresults(results) + local context = self:getcontext() + + if self._keep_eval_lastn then + context._ = nil + + for i = 1, self._keep_eval_lastn do + context['_' .. tostring(i)] = nil + end + end + + if results.n > 0 then + context._ = results[1] + + for i = 1, results.n do + context['_' .. tostring(i)] = results[i] + end + + self._keep_eval_lastn = results.n + end +end diff --git a/lib/lua-repl/repl/plugins/linenoise.lua b/lib/lua-repl/repl/plugins/linenoise.lua new file mode 100644 index 00000000..4407c535 --- /dev/null +++ b/lib/lua-repl/repl/plugins/linenoise.lua @@ -0,0 +1,59 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +-- A plugin that uses linenoise (https://github.com/hoelzro/lua-linenoise) for prompting + +local ln = require 'linenoise' + +repl:requirefeature 'console' + +function override:showprompt(prompt) + self._prompt = prompt -- XXX how do we make sure other plugins don't step on this? +end + +function override:lines() + return function() + return ln.linenoise(self._prompt .. ' ') + end +end + +repl:iffeature('completion', function() + ln.setcompletion(function(completions, line) + repl:complete(line, function(completion) + ln.addcompletion(completions, completion) + end) + end) +end) + +repl:ifplugin('history', function() + repl:setuphistorycallbacks { + load = function(filename) + ln.historyload(filename) + end, + + addline = function(line) + ln.historyadd(line) + end, + + save = function(filename) + ln.historysave(filename) + end, + } +end) + +features = 'input' diff --git a/lib/lua-repl/repl/plugins/pretty_print.lua b/lib/lua-repl/repl/plugins/pretty_print.lua new file mode 100644 index 00000000..2318f444 --- /dev/null +++ b/lib/lua-repl/repl/plugins/pretty_print.lua @@ -0,0 +1,262 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +-- Pretty prints expression results (console only) + +local format = string.format +local tconcat = table.concat +local tsort = table.sort +local tostring = tostring +local type = type +local floor = math.floor +local pairs = pairs +local ipairs = ipairs +local error = error +local stderr = io.stderr + +pcall(require, 'luarocks.require') +local ok, term = pcall(require, 'term') +if not ok then + term = nil +end + +local keywords = { + ['and'] = true, + ['break'] = true, + ['do'] = true, + ['else'] = true, + ['elseif'] = true, + ['end'] = true, + ['false'] = true, + ['for'] = true, + ['function'] = true, + ['if'] = true, + ['in'] = true, + ['local'] = true, + ['nil'] = true, + ['not'] = true, + ['or'] = true, + ['repeat'] = true, + ['return'] = true, + ['then'] = true, + ['true'] = true, + ['until'] = true, + ['while'] = true, +} + +local function compose(f, g) + return function(...) + return f(g(...)) + end +end + +local emptycolormap = setmetatable({}, { __index = function() + return function(s) + return s + end +end}) + +local colormap = emptycolormap + +if term then + colormap = { + ['nil'] = term.colors.blue, + string = term.colors.yellow, + punctuation = compose(term.colors.green, term.colors.bright), + ident = term.colors.red, + boolean = term.colors.green, + number = term.colors.cyan, + path = term.colors.white, + misc = term.colors.magenta, + } +end + +local function isinteger(n) + return type(n) == 'number' and floor(n) == n +end + +local function isident(s) + return type(s) == 'string' and not keywords[s] and s:match('^[a-zA-Z_][a-zA-Z0-9_]*$') +end + +-- most of these are arbitrary, I *do* want numbers first, though +local type_order = { + number = 0, + string = 1, + userdata = 2, + table = 3, + thread = 4, + boolean = 5, + ['function'] = 6, + cdata = 7, +} + +local function cross_type_order(a, b) + local pos_a = type_order[ type(a) ] + local pos_b = type_order[ type(b) ] + + if pos_a == pos_b then + return a < b + else + return pos_a < pos_b + end +end + +local function sortedpairs(t) + local keys = {} + + local seen_non_string + + for k in pairs(t) do + keys[#keys + 1] = k + + if not seen_non_string and type(k) ~= 'string' then + seen_non_string = true + end + end + + local sort_func = seen_non_string and cross_type_order or nil + tsort(keys, sort_func) + + local index = 1 + return function() + if keys[index] == nil then + return nil + else + local key = keys[index] + local value = t[key] + index = index + 1 + + return key, value + end + end, keys +end + +local function find_longstring_nest_level(s) + local level = 0 + + while s:find(']' .. string.rep('=', level) .. ']', 1, true) do + level = level + 1 + end + + return level +end + +local function dump(params) + local pieces = params.pieces + local seen = params.seen + local path = params.path + local v = params.value + local indent = params.indent + + local t = type(v) + + if t == 'nil' or t == 'boolean' or t == 'number' then + pieces[#pieces + 1] = colormap[t](tostring(v)) + elseif t == 'string' then + if v:match '\n' then + local level = find_longstring_nest_level(v) + pieces[#pieces + 1] = colormap.string('[' .. string.rep('=', level) .. '[' .. v .. ']' .. string.rep('=', level) .. ']') + else + pieces[#pieces + 1] = colormap.string(format('%q', v)) + end + elseif t == 'table' then + if seen[v] then + pieces[#pieces + 1] = colormap.path(seen[v]) + return + end + + seen[v] = path + + local lastintkey = 0 + + pieces[#pieces + 1] = colormap.punctuation '{\n' + for i, v in ipairs(v) do + for j = 1, indent do + pieces[#pieces + 1] = ' ' + end + dump { + pieces = pieces, + seen = seen, + path = path .. '[' .. tostring(i) .. ']', + value = v, + indent = indent + 1, + } + pieces[#pieces + 1] = colormap.punctuation ',\n' + lastintkey = i + end + + for k, v in sortedpairs(v) do + if not (isinteger(k) and k <= lastintkey and k > 0) then + for j = 1, indent do + pieces[#pieces + 1] = ' ' + end + + if isident(k) then + pieces[#pieces + 1] = colormap.ident(k) + else + pieces[#pieces + 1] = colormap.punctuation '[' + dump { + pieces = pieces, + seen = seen, + path = path .. '.' .. tostring(k), + value = k, + indent = indent + 1, + } + pieces[#pieces + 1] = colormap.punctuation ']' + end + pieces[#pieces + 1] = colormap.punctuation ' = ' + dump { + pieces = pieces, + seen = seen, + path = path .. '.' .. tostring(k), + value = v, + indent = indent + 1, + } + pieces[#pieces + 1] = colormap.punctuation ',\n' + end + end + + for j = 1, indent - 1 do + pieces[#pieces + 1] = ' ' + end + + pieces[#pieces + 1] = colormap.punctuation '}' + else + pieces[#pieces + 1] = colormap.misc(tostring(v)) + end +end + +repl:requirefeature 'console' + +function override:displayresults(results) + local pieces = {} + + for i = 1, results.n do + dump { + pieces = pieces, + seen = {}, + path = '<topvalue>', + value = results[i], + indent = 1, + } + pieces[#pieces + 1] = '\n' + end + + stderr:write(tconcat(pieces, '')) +end diff --git a/lib/lua-repl/repl/plugins/rcfile.lua b/lib/lua-repl/repl/plugins/rcfile.lua new file mode 100644 index 00000000..a74e81ac --- /dev/null +++ b/lib/lua-repl/repl/plugins/rcfile.lua @@ -0,0 +1,54 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +-- A plugin that runs code in $HOME/.rep.lua before the REPL starts + +local setfenv = require('repl.utils').setfenv + +local function readable(filename) + local f = io.open(filename, 'r') + if not f then + return false + end + f:close() + return true +end + +local function init() + local home = os.getenv 'HOME' + + if not home then + return + end + + local rcfile = home .. '/.rep.lua' + + if not readable(rcfile) then + return + end + + local chunk = assert(loadfile(rcfile)) + local env = setmetatable({ repl = repl }, { __index = _G, __newindex = _G }) + + setfenv(chunk, env) + + chunk() + return true +end + +return init() diff --git a/lib/lua-repl/repl/plugins/rlwrap.lua b/lib/lua-repl/repl/plugins/rlwrap.lua new file mode 100644 index 00000000..9f195a3f --- /dev/null +++ b/lib/lua-repl/repl/plugins/rlwrap.lua @@ -0,0 +1,41 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +if os.getenv 'LUA_REPL_RLWRAP' then + features = 'input' +else + -- XXX check that we're not receiving input from a non-tty + local has_rlwrap = os.execute('which rlwrap >/dev/null 2>/dev/null') + + if type(has_rlwrap) ~= 'boolean' then + has_rlwrap = has_rlwrap == 0 + end + + if not has_rlwrap then + error 'Please install rlwrap in order to use the rlwrap plugin' + end + + local lowest_index = -1 + + while arg[lowest_index] ~= nil do + lowest_index = lowest_index - 1 + end + lowest_index = lowest_index + 1 + os.execute(string.format('LUA_REPL_RLWRAP=1 rlwrap %q %q', arg[lowest_index], arg[0])) + os.exit(0) +end diff --git a/lib/lua-repl/repl/plugins/semicolon_suppress_output.lua b/lib/lua-repl/repl/plugins/semicolon_suppress_output.lua new file mode 100644 index 00000000..4adaecb6 --- /dev/null +++ b/lib/lua-repl/repl/plugins/semicolon_suppress_output.lua @@ -0,0 +1,36 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +local smatch = string.match + +-- XXX will this affect any other plugins? +function around:compilechunk(orig, chunk) + local f, err = orig(self, chunk) + + if not f then + return f, err + end + + if smatch(chunk, ';%s*$') then + return function() + f() + end + end + + return f +end diff --git a/lib/lua-repl/repl/sync.lua b/lib/lua-repl/repl/sync.lua new file mode 100644 index 00000000..a422ed4b --- /dev/null +++ b/lib/lua-repl/repl/sync.lua @@ -0,0 +1,46 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +local repl = require 'repl' +local sync_repl = repl:clone() +local error = error + +-- @class repl.sync +--- This module implements a synchronous REPL. It provides +--- a run() method for actually running the REPL, and requires +--- that implementors implement the lines() method. + +--- Run a REPL loop in a synchronous fashion. +-- @name repl.sync:run +function sync_repl:run() + self:prompt(1) + for line in self:lines() do + local level = self:handleline(line) + self:prompt(level) + end + self:shutdown() +end + +--- Returns an iterator that yields lines to be evaluated. +-- @name repl.sync:lines +-- @return An iterator. +function sync_repl:lines() + error 'You must implement the lines method' +end + +return sync_repl diff --git a/lib/lua-repl/repl/utils.lua b/lib/lua-repl/repl/utils.lua new file mode 100644 index 00000000..3e2ca18f --- /dev/null +++ b/lib/lua-repl/repl/utils.lua @@ -0,0 +1,70 @@ +-- Copyright (c) 2011-2015 Rob Hoelz <rob@hoelz.ro> +-- +-- Permission is hereby granted, free of charge, to any person obtaining a copy of +-- this software and associated documentation files (the "Software"), to deal in +-- the Software without restriction, including without limitation the rights to +-- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +-- the Software, and to permit persons to whom the Software is furnished to do so, +-- subject to the following conditions: +-- +-- The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +-- +-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +-- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +-- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +-- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +-- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +-- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +local setfenv = setfenv or function(f, t) + local upvalue_index = 1 + + -- XXX we may need a utility library if debug isn't available + while true do + local name = debug.getupvalue(f, upvalue_index) + -- some functions don't have an _ENV upvalue, because + -- they never refer to globals + if not name then + return + end + if name == '_ENV' then + debug.setupvalue(f, upvalue_index, t) + return + end + upvalue_index = upvalue_index + 1 + end +end + +--- Tests wheter an expression ends in an unfinished string literal. +-- @return First position in the unfinished string literal or `nil`. +local function ends_in_unfinished_string(expr) + local position = 0 + local quote + local current_delimiter + local last_unmatched_start + while true do + -- find all quotes: + position, quote = expr:match('()([\'"])', position+1) + if not position then break end + -- if we're currently in a string: + if current_delimiter then + -- would end current string? + if current_delimiter == quote then + -- not escaped? + if expr:sub(position-1, position-1) ~= '\\' then + current_delimiter = nil + last_unmatched_start = nil + end + end + else + current_delimiter = quote + last_unmatched_start = position+1 + end + end + return last_unmatched_start +end + +return { + setfenv = setfenv, + ends_in_unfinished_string = ends_in_unfinished_string +} diff --git a/lib/lua-repl/t/abstract-repl-tests.lua b/lib/lua-repl/t/abstract-repl-tests.lua new file mode 100644 index 00000000..50d4b07c --- /dev/null +++ b/lib/lua-repl/t/abstract-repl-tests.lua @@ -0,0 +1,33 @@ +-- vim:foldmethod=marker +local repl = require 'repl' +pcall(require, 'luarocks.loader') +require 'Test.More' + +plan(8) + +do -- getprompt tests {{{ + is(repl:getprompt(1), '>') + is(repl:getprompt(2), '>>') +end -- }}} + +do -- prompt abstract tests {{{ + error_like(function() + repl:prompt(1) + end, 'You must implement the showprompt method') + + error_like(function() + repl:prompt(2) + end, 'You must implement the showprompt method') +end -- }}} + +do -- name tests {{{ + is(repl:name(), 'REPL') +end -- }}} + +do -- handleline abstract tests {{{ + is(_G.testresult, nil) + error_like(function() + repl:handleline '_G.testresult = 17' + end, 'You must implement the displayresults method') + is(_G.testresult, 17) +end -- }}} diff --git a/lib/lua-repl/t/clone-repl-tests.lua b/lib/lua-repl/t/clone-repl-tests.lua new file mode 100644 index 00000000..3ec82f92 --- /dev/null +++ b/lib/lua-repl/t/clone-repl-tests.lua @@ -0,0 +1,119 @@ +-- vim:foldmethod=marker +local repl = require 'repl' +pcall(require, 'luarocks.loader') +require 'Test.More' + +plan(45) + +local clone = repl:clone() +local prompt +local results +local errmsg + +isnt(type(clone), 'nil') + +function clone:showprompt(p) + prompt = p +end + +function clone:displayresults(r) + results = r +end + +function clone:displayerror(err) + errmsg = err +end + +do -- prompt tests {{{ + lives_ok(function() + clone:prompt(1) + end) + + is(prompt, '>') + + lives_ok(function() + clone:prompt(2) + end) + + is(prompt, '>>') +end -- }}} + +do -- handleline tests {{{ + is(_G.testresult, nil) + is(results, nil) + + lives_ok(function() + clone:handleline '_G.testresult = 18' + end) + + is(_G.testresult, 18) + + is(type(results), 'table') + is(results.n, 0) + is(#results, 0) + + lives_ok(function() + clone:handleline 'return 19' + end) + + is(type(results), 'table') + is(results.n, 1) + is(#results, 1) + is(results[1], 19) + + lives_ok(function() + clone:handleline 'return 20, 21, 22' + end) + + is(type(results), 'table') + is(results.n, 3) + is(#results, 3) + is(results[1], 20) + is(results[2], 21) + is(results[3], 22) + + lives_ok(function() + clone:handleline 'return 1, nil, nil, nil, nil, nil, nil, 2' + end) + + is(type(results), 'table') + is(results.n, 8) + is(results[1], 1) + for i = 2, 7 do + is(results[i], nil) + end + is(results[8], 2) +end -- }}} + +do -- error handling tests {{{ + lives_ok(function() + clone:handleline '3 4' + end) + + isnt(type(errmsg), 'nil') + + errmsg = nil + + lives_ok(function() + clone:handleline 'error "foo"' + end) + + like(errmsg, 'foo') +end -- }}} + +do -- multi-line input tests {{{ + errmsg = nil + _G.t = {} + + lives_ok(function() + clone:handleline 'for i = 1, 3 do' + clone:handleline ' table.insert(_G.t, i)' + clone:handleline 'end' + end) + + is(errmsg, nil) + is(#_G.t, 3) + is(_G.t[1], 1) + is(_G.t[2], 2) + is(_G.t[3], 3) +end -- }}} diff --git a/lib/lua-repl/t/lib/test-utils.lua b/lib/lua-repl/t/lib/test-utils.lua new file mode 100644 index 00000000..a0bb16ac --- /dev/null +++ b/lib/lua-repl/t/lib/test-utils.lua @@ -0,0 +1,56 @@ +local _M = {} + +function _M.next_line_number() + local info = debug.getinfo(2, 'l') + return info.currentline + 1 -- doesn't work with whitespace +end + +function _M.cmp_tables(lhs, rhs) + local ok = true + local got + local expected + local failing_k + + for k, v in pairs(lhs) do + local rv = rhs[k] + + if v ~= rv then + ok = false + failing_k = k + got = v + expected = rv + break + end + end + + if ok then + for k, v in pairs(rhs) do + local lv = lhs[k] + + if v ~= lv then + ok = false + failing_k = k + got = lv + expected = v + break + end + end + end + + if ok then + pass() + else + fail 'value mismatch' + diag(string.format(' got[%q]: %s', tostring(failing_k), tostring(got))) + diag(string.format('expected[%q]: %s', tostring(failing_k), tostring(expected))) + end +end + +function _M.gather_results(...) + return { + n = select('#', ...), + ..., + } +end + +return _M diff --git a/lib/lua-repl/t/plugin-after-tests.lua b/lib/lua-repl/t/plugin-after-tests.lua new file mode 100644 index 00000000..15a24c11 --- /dev/null +++ b/lib/lua-repl/t/plugin-after-tests.lua @@ -0,0 +1,202 @@ +-- vim:foldmethod=marker +local repl = require 'repl' +pcall(require, 'luarocks.loader') +require 'Test.More' +local utils = require 'test-utils' + +plan(26) + +local clone = repl:clone() + +do -- basic tests {{{ + local with_plugin = clone:clone() + + local has_called_normal + local has_called_after + + function with_plugin:foo() + has_called_normal = true + end + + with_plugin:loadplugin(function() + function after:foo() + has_called_after = true + ok(has_called_normal) + end + end) + + with_plugin:foo() + ok(has_called_normal) + ok(has_called_after) + + local line_no + + local _, err = pcall(function() + with_plugin:loadplugin(function() + line_no = utils.next_line_number() + function after:nonexistent() + end + end) + end) + + like(err, string.format("%d: The 'nonexistent' method does not exist", line_no)) + + _, err = pcall(function() + with_plugin:loadplugin(function() + line_no = utils.next_line_number() + after.foo = 17 + end) + end) + + like(err, string.format('%d: 17 is not a function', line_no)) +end -- }}} + +do -- arguments tests {{{ + local with_plugin = clone:clone() + local orig_args + local got_args + + function with_plugin:foo(...) + orig_args = { + n = select('#', ...), + ..., + } + end + + with_plugin:loadplugin(function() + function after:foo(...) + got_args = { + n = select('#', ...), + ..., + } + end + end) + + with_plugin:foo() + is(got_args.n, 0) + utils.cmp_tables(orig_args, got_args) + + with_plugin:foo(1, 2, 3) + is(got_args.n, 3) + is(got_args[1], 1) + is(got_args[2], 2) + is(got_args[3], 3) + utils.cmp_tables(orig_args, got_args) + + with_plugin:foo(1, nil, nil, nil, 5) + is(got_args.n, 5) + is(got_args[1], 1) + is(got_args[2], nil) + is(got_args[3], nil) + is(got_args[4], nil) + is(got_args[5], 5) + utils.cmp_tables(orig_args, got_args) +end -- }}} + +do -- exception tests {{{ + local with_plugin = clone:clone() + + local has_called_original + + function with_plugin:foo() + has_called_original = true + end + + with_plugin:loadplugin(function() + function after:foo() + error 'uh-oh' + end + end) + + local _, err = pcall(with_plugin.foo, with_plugin) + + like(err, 'uh%-oh') + ok(has_called_original) +end -- }}} + +do -- return value tests {{{ + local with_plugin = clone:clone() + + function with_plugin:foo() + return 17 + end + + function with_plugin:bar() + return 18, 19, 20 + end + + function with_plugin:baz() + return 1, nil, nil, nil, 5 + end + + with_plugin:loadplugin(function() + function after:foo() + return 18 + end + + function after:bar() + return 18 + end + + function after:baz() + return 18 + end + end) + + local result = with_plugin:foo() + is(result, 17) + + local results = utils.gather_results(with_plugin:bar()) + utils.cmp_tables(results, { n = 3, 18, 19, 20 }) + + results = utils.gather_results(with_plugin:baz()) + utils.cmp_tables(results, { n = 5, 1, nil, nil, nil, 5 }) +end -- }}} + +do -- multiple advice, multiple plugins {{{ + local with_plugin = clone:clone() + local calls = {} + + function with_plugin:foo() + calls[#calls + 1] = 'original' + end + + with_plugin:loadplugin(function() + function after:foo() + calls[#calls + 1] = 'first' + end + end) + + with_plugin:loadplugin(function() + function after:foo() + calls[#calls + 1] = 'second' + end + end) + + with_plugin:foo() + + utils.cmp_tables(calls, { 'original', 'first', 'second' }) +end -- }}} + +do -- multiple advice, single plugin {{{ + local with_plugin = clone:clone() + local calls = {} + + function with_plugin:foo() + calls[#calls + 1] = 'original' + end + + with_plugin:loadplugin(function() + function after:foo() + calls[#calls + 1] = 'first' + end + + function after:foo() + calls[#calls + 1] = 'second' + end + end) + + with_plugin:foo() + + utils.cmp_tables(calls, { 'original', 'first', 'second' }) +end -- }}} diff --git a/lib/lua-repl/t/plugin-around-tests.lua b/lib/lua-repl/t/plugin-around-tests.lua new file mode 100644 index 00000000..df0ea073 --- /dev/null +++ b/lib/lua-repl/t/plugin-around-tests.lua @@ -0,0 +1,218 @@ +-- vim:foldmethod=marker +local repl = require 'repl' +local compat = require 'repl.compat' +pcall(require, 'luarocks.loader') +require 'Test.More' +local utils = require 'test-utils' + +plan(27) + +local clone = repl:clone() + +do -- basic tests {{{ + local with_plugin = clone:clone() + + local has_called_normal + local has_called_around + + function with_plugin:foo() + has_called_normal = true + end + + with_plugin:loadplugin(function() + function around:foo(orig, ...) + has_called_around = true + ok(not has_called_normal) + local return_values = utils.gather_results(orig(self, ...)) + ok(has_called_normal) + return compat.unpack(return_values, 1, return_values.n) + end + end) + + with_plugin:foo() + ok(has_called_normal) + ok(has_called_around) + + local line_no + + local _, err = pcall(function() + with_plugin:loadplugin(function() + line_no = utils.next_line_number() + function around:nonexistent() + end + end) + end) + + like(err, string.format("%d: The 'nonexistent' method does not exist", line_no)) + + _, err = pcall(function() + with_plugin:loadplugin(function() + line_no = utils.next_line_number() + around.foo = 17 + end) + end) + + like(err, string.format('%d: 17 is not a function', line_no)) +end -- }}} + +do -- arguments tests {{{ + local with_plugin = clone:clone() + local orig_args + local got_args + + function with_plugin:foo(...) + orig_args = { + n = select('#', ...), + ..., + } + end + + with_plugin:loadplugin(function() + function around:foo(orig, ...) + got_args = { + n = select('#', ...), + ..., + } + + return orig(self, ...) + end + end) + + with_plugin:foo() + is(got_args.n, 0) + utils.cmp_tables(orig_args, got_args) + + with_plugin:foo(1, 2, 3) + is(got_args.n, 3) + is(got_args[1], 1) + is(got_args[2], 2) + is(got_args[3], 3) + utils.cmp_tables(orig_args, got_args) + + with_plugin:foo(1, nil, nil, nil, 5) + is(got_args.n, 5) + is(got_args[1], 1) + is(got_args[2], nil) + is(got_args[3], nil) + is(got_args[4], nil) + is(got_args[5], 5) + utils.cmp_tables(orig_args, got_args) +end -- }}} + +do -- exception tests {{{ + local with_plugin = clone:clone() + + local has_called_original + + function with_plugin:foo() + has_called_original = true + end + + with_plugin:loadplugin(function() + function around:foo() + error 'uh-oh' + end + end) + + local _, err = pcall(with_plugin.foo, with_plugin) + + like(err, 'uh%-oh') + ok(not has_called_original) +end -- }}} + +do -- return value tests {{{ + local with_plugin = clone:clone() + + function with_plugin:foo() + return 17 + end + + function with_plugin:bar() + return 18, 19, 20 + end + + function with_plugin:baz() + return 1, nil, nil, nil, 5 + end + + with_plugin:loadplugin(function() + function around:foo() + return 18 + end + + function around:bar() + return 19, 20, 21 + end + + function around:baz() + return 1, nil, nil, 4 + end + end) + + local result = with_plugin:foo() + is(result, 18) + + local results = utils.gather_results(with_plugin:bar()) + utils.cmp_tables(results, { n = 3, 19, 20, 21 }) + + results = utils.gather_results(with_plugin:baz()) + utils.cmp_tables(results, { n = 4, 1, nil, nil, 4 }) +end -- }}} + +do -- multiple advice, multiple plugins {{{ + local with_plugin = clone:clone() + local calls = {} + + function with_plugin:foo() + calls[#calls + 1] = 'original' + end + + with_plugin:loadplugin(function() + function around:foo(orig) + calls[#calls + 1] = 'before_one' + orig() + calls[#calls + 1] = 'after_one' + end + end) + + with_plugin:loadplugin(function() + function around:foo(orig) + calls[#calls + 1] = 'before_two' + orig() + calls[#calls + 1] = 'after_two' + end + end) + + with_plugin:foo() + + utils.cmp_tables(calls, { 'before_two', 'before_one', 'original', + 'after_one', 'after_two' }) +end -- }}} + +do -- multiple advice, single plugin {{{ + local with_plugin = clone:clone() + local calls = {} + + function with_plugin:foo() + calls[#calls + 1] = 'original' + end + + with_plugin:loadplugin(function() + function around:foo(orig) + calls[#calls + 1] = 'before_one' + orig() + calls[#calls + 1] = 'after_one' + end + + function around:foo(orig) + calls[#calls + 1] = 'before_two' + orig() + calls[#calls + 1] = 'after_two' + end + end) + + with_plugin:foo() + + utils.cmp_tables(calls, { 'before_two', 'before_one', 'original', + 'after_one', 'after_two' }) +end -- }}} diff --git a/lib/lua-repl/t/plugin-basic-tests.lua b/lib/lua-repl/t/plugin-basic-tests.lua new file mode 100644 index 00000000..21283ef8 --- /dev/null +++ b/lib/lua-repl/t/plugin-basic-tests.lua @@ -0,0 +1,206 @@ +-- vim:foldmethod=marker +local repl = require 'repl' +local utils = require 'test-utils' +pcall(require, 'luarocks.loader') +require 'Test.More' + +plan(28) + +local clone = repl:clone() + +do -- basic tests {{{ + local loaded + + clone:loadplugin(function() + loaded = true + end) + + ok(loaded) + + error_like(function() + clone:loadplugin(function() + error 'uh-oh' + end) + end, 'uh%-oh') + +end -- }}} + +do -- loading the same plugin twice {{{ + local function plugin() + end + + local line_no + + clone:loadplugin(plugin) + local _, err = pcall(function() + line_no = utils.next_line_number() + clone:loadplugin(plugin) + end) + like(err, tostring(line_no) .. ': plugin "function:%s+%S+" has already been loaded') + + _, err = pcall(function() + line_no = utils.next_line_number() + clone:clone():loadplugin(plugin) + end) + like(err, tostring(line_no) .. ': plugin "function:%s+%S+" has already been loaded') + + repl:clone():loadplugin(plugin) + repl:clone():loadplugin(plugin) +end -- }}} + +do -- loading plugins by name {{{ + local loaded + + package.preload['repl.plugins.test'] = function() + loaded = true + end + + clone:clone():loadplugin 'test' + + ok(loaded) + loaded = false + + clone:clone():loadplugin 'test' + + ok(loaded, 'loading a plugin twice should initialize it twice') + + package.preload['repl.plugins.test'] = function() + error 'uh-oh' + end + + error_like(function() + clone:clone():loadplugin 'test' + end, 'uh%-oh') + + package.preload['repl.plugins.test'] = nil + + local line_no + + local _, err = pcall(function() + line_no = utils.next_line_number() + clone:clone():loadplugin 'test' + end) + like(err, tostring(line_no) .. ': unable to locate plugin') +end -- }}} + +do -- hasplugin tests {{{ + local child = repl:clone() + + local plugin = function() + end + + child:loadplugin(plugin) + + local grandchild = child:clone() + + ok(not repl:hasplugin(plugin)) + ok(child:hasplugin(plugin)) + ok(grandchild:hasplugin(plugin)) + + plugin = function() + end + + child:loadplugin(plugin) + + ok(not repl:hasplugin(plugin)) + ok(child:hasplugin(plugin)) + ok(not grandchild:hasplugin(plugin)) +end -- }}} + +do -- global tests {{{ + local clone = repl:clone() + local line_no + + local _, err = pcall(function() + clone:loadplugin(function() + line_no = utils.next_line_number() + foo = 17 + end) + end) + + like(err, tostring(line_no) .. ': global environment is read%-only %(key = "foo"%)') + + _, err = pcall(function() + clone:loadplugin(function() + line_no = utils.next_line_number() + _G.foo = 17 + end) + end) + + like(err, tostring(line_no) .. ': global environment is read%-only %(key = "foo"%)') +end -- }}} + +do -- ifplugin tests {{{ + local clone = repl:clone() + local has_run + + package.preload['repl.plugins.test'] = function() + end + + clone:ifplugin('test', function() + has_run = true + end) + + ok(not has_run) + + clone:loadplugin 'test' + + ok(has_run) + + has_run = false + + clone:ifplugin('test', function() + has_run = true + end) + + ok(has_run) +end -- }}} + +do -- ifplugin multiple times {{{ + local clone = repl:clone() + local has_run + local has_run2 + + package.preload['repl.plugins.test'] = function() + end + + clone:ifplugin('test', function() + has_run = true + end) + + clone:ifplugin('test', function() + has_run2 = true + end) + + clone:loadplugin 'test' + + ok(has_run) + ok(has_run2) +end -- }}} + +do -- plugin return value {{{ + local clone = repl:clone() + + local result = clone:loadplugin(function() + return 17 + end) + + local result2 = clone:loadplugin(function() + end) + + local result3, result4 = clone:loadplugin(function() + return 18, 19 + end) + + local result5, result6, result7 = clone:loadplugin(function() + return 20, nil, 21 + end) + + is(result, 17) + is(result2, nil) + is(result3, 18) + is(result4, 19) + is(result5, 20) + is(result6, nil) + is(result7, 21) +end -- }}} diff --git a/lib/lua-repl/t/plugin-before-tests.lua b/lib/lua-repl/t/plugin-before-tests.lua new file mode 100644 index 00000000..cc23ba78 --- /dev/null +++ b/lib/lua-repl/t/plugin-before-tests.lua @@ -0,0 +1,201 @@ +-- vim:foldmethod=marker +local repl = require 'repl' +pcall(require, 'luarocks.loader') +require 'Test.More' +local utils = require 'test-utils' + +plan(26) + +local clone = repl:clone() + +do -- basic tests {{{ + local with_plugin = clone:clone() + + local has_called_normal + local has_called_before + + function with_plugin:foo() + has_called_normal = true + end + + with_plugin:loadplugin(function() + function before:foo() + has_called_before = true + ok(not has_called_normal) + end + end) + + with_plugin:foo() + ok(has_called_normal) + ok(has_called_before) + + local line_no + + local _, err = pcall(function() + with_plugin:loadplugin(function() + line_no = utils.next_line_number() + function before:nonexistent() + end + end) + end) + + like(err, string.format("%d: The 'nonexistent' method does not exist", line_no)) + + _, err = pcall(function() + with_plugin:loadplugin(function() + line_no = utils.next_line_number() + before.foo = 17 + end) + end) + + like(err, string.format('%d: 17 is not a function', line_no)) +end -- }}} + +do -- arguments tests {{{ + local with_plugin = clone:clone() + local orig_args + local got_args + + function with_plugin:foo(...) + orig_args = { + n = select('#', ...), + ..., + } + end + + with_plugin:loadplugin(function() + function before:foo(...) + got_args = { + n = select('#', ...), + ..., + } + end + end) + + with_plugin:foo() + is(got_args.n, 0) + utils.cmp_tables(orig_args, got_args) + + with_plugin:foo(1, 2, 3) + is(got_args.n, 3) + is(got_args[1], 1) + is(got_args[2], 2) + is(got_args[3], 3) + utils.cmp_tables(orig_args, got_args) + + with_plugin:foo(1, nil, nil, nil, 5) + is(got_args.n, 5) + is(got_args[1], 1) + is(got_args[2], nil) + is(got_args[3], nil) + is(got_args[4], nil) + is(got_args[5], 5) + utils.cmp_tables(orig_args, got_args) +end -- }}} + +do -- exception tests {{{ + local with_plugin = clone:clone() + + local has_called_original + + function with_plugin:foo() + has_called_original = true + end + + with_plugin:loadplugin(function() + function before:foo() + error 'uh-oh' + end + end) + + local _, err = pcall(with_plugin.foo, with_plugin) + + like(err, 'uh%-oh') + ok(not has_called_original) +end -- }}} + +do -- return value tests {{{ + local with_plugin = clone:clone() + + function with_plugin:foo() + return 17 + end + + function with_plugin:bar() + return 18, 19, 20 + end + + function with_plugin:baz() + return 1, nil, nil, nil, 5 + end + + with_plugin:loadplugin(function() + function before:foo() + return 18 + end + + function before:bar() + return 18 + end + + function before:baz() + end + end) + + local result = with_plugin:foo() + is(result, 17) + + local results = utils.gather_results(with_plugin:bar()) + utils.cmp_tables(results, { n = 3, 18, 19, 20 }) + + results = utils.gather_results(with_plugin:baz()) + utils.cmp_tables(results, { n = 5, 1, nil, nil, nil, 5 }) +end -- }}} + +do -- multiple advice, multiple plugins {{{ + local with_plugin = clone:clone() + local calls = {} + + function with_plugin:foo() + calls[#calls + 1] = 'original' + end + + with_plugin:loadplugin(function() + function before:foo() + calls[#calls + 1] = 'first' + end + end) + + with_plugin:loadplugin(function() + function before:foo() + calls[#calls + 1] = 'second' + end + end) + + with_plugin:foo() + + utils.cmp_tables(calls, { 'second', 'first', 'original' }) +end -- }}} + +do -- multiple advice, single plugin {{{ + local with_plugin = clone:clone() + local calls = {} + + function with_plugin:foo() + calls[#calls + 1] = 'original' + end + + with_plugin:loadplugin(function() + function before:foo() + calls[#calls + 1] = 'first' + end + + function before:foo() + calls[#calls + 1] = 'second' + end + end) + + with_plugin:foo() + + utils.cmp_tables(calls, { 'second', 'first', 'original' }) +end -- }}} diff --git a/lib/lua-repl/t/plugin-feature-tests.lua b/lib/lua-repl/t/plugin-feature-tests.lua new file mode 100644 index 00000000..4c74a4c1 --- /dev/null +++ b/lib/lua-repl/t/plugin-feature-tests.lua @@ -0,0 +1,132 @@ +-- vim:foldmethod=marker +local repl = require 'repl' +local utils = require 'test-utils' +pcall(require, 'luarocks.loader') +require 'Test.More' + +plan(19) + +do -- basic tests {{{ + local clone = repl:clone() + + clone:loadplugin(function() + features = 'foo' + end) + + ok(clone:hasfeature 'foo') + ok(not clone:hasfeature 'bar') + ok(not clone:hasfeature 'baz') + + clone:loadplugin(function() + features = { 'bar', 'baz' } + end) + + ok(clone:hasfeature 'foo') + ok(clone:hasfeature 'bar') + ok(clone:hasfeature 'baz') +end -- }}} + +do -- requirefeature {{{ + local clone = repl:clone() + + clone:loadplugin(function() + features = 'foo' + end) + + clone:requirefeature 'foo' + + local line_no + local _, err = pcall(function() + line_no = utils.next_line_number() + clone:requirefeature 'bar' + end) + + like(err, tostring(line_no) .. ': required feature "bar" not present') +end -- }}} + +do -- conflicts {{{ + local clone = repl:clone() + local line_no + + clone:loadplugin(function() + features = 'foo' + end) + + local _, err = pcall(function() + line_no = utils.next_line_number() + clone:loadplugin(function() + features = 'foo' + end) + end) + like(err, tostring(line_no) .. ': feature "foo" already present') + + -- XXX what about methods injected into the object? +end -- }}} + +do -- clone:hasfeature {{{ + local child = repl:clone() + + child:loadplugin(function() + features = 'foo' + end) + + local grandchild = child:clone() + + ok(not repl:hasfeature 'foo') + ok(child:hasfeature 'foo') + ok(grandchild:hasfeature 'foo') + + child:loadplugin(function() + features = 'bar' + end) + + ok(not repl:hasfeature 'bar') + ok(child:hasfeature 'bar') + ok(not grandchild:hasfeature 'bar') +end -- }}} + +do -- iffeature tests {{{ + local clone = repl:clone() + local has_run + + clone:iffeature('foo', function() + has_run = true + end) + + ok(not has_run) + + clone:loadplugin(function() + features = 'foo' + end) + + ok(has_run) + + has_run = false + + clone:iffeature('foo', function() + has_run = true + end) + + ok(has_run) +end -- }}} + +do -- iffeature multiple times {{{ + local clone = repl:clone() + local has_run + local has_run2 + + clone:iffeature('foo', function() + has_run = true + end) + + clone:iffeature('foo', function() + has_run2 = true + end) + + clone:loadplugin(function() + features = 'foo' + end) + + ok(has_run) + ok(has_run2) +end -- }}} diff --git a/lib/lua-repl/t/plugin-override-tests.lua b/lib/lua-repl/t/plugin-override-tests.lua new file mode 100644 index 00000000..6ea11d8b --- /dev/null +++ b/lib/lua-repl/t/plugin-override-tests.lua @@ -0,0 +1,201 @@ +-- vim:foldmethod=marker +local repl = require 'repl' +pcall(require, 'luarocks.loader') +require 'Test.More' +local utils = require 'test-utils' + +plan(25) + +local clone = repl:clone() + +do -- basic tests {{{ + local with_plugin = clone:clone() + + local has_called_normal + local has_called_override + + function with_plugin:foo() + has_called_normal = true + end + + with_plugin:loadplugin(function() + function override:foo() + has_called_override = true + end + end) + + with_plugin:foo() + ok(not has_called_normal) + ok(has_called_override) + + local line_no + + local _, err = pcall(function() + with_plugin:loadplugin(function() + line_no = utils.next_line_number() + function override:nonexistent() + end + end) + end) + + like(err, string.format("%d: The 'nonexistent' method does not exist", line_no)) + + _, err = pcall(function() + with_plugin:loadplugin(function() + line_no = utils.next_line_number() + override.foo = 17 + end) + end) + + like(err, string.format('%d: 17 is not a function', line_no)) +end -- }}} + +do -- arguments tests {{{ + local with_plugin = clone:clone() + local orig_args + local got_args + + function with_plugin:foo(...) + orig_args = { + n = select('#', ...), + ..., + } + end + + with_plugin:loadplugin(function() + function override:foo(...) + got_args = { + n = select('#', ...), + ..., + } + end + end) + + with_plugin:foo() + is(got_args.n, 0) + ok(not orig_args) + + with_plugin:foo(1, 2, 3) + is(got_args.n, 3) + is(got_args[1], 1) + is(got_args[2], 2) + is(got_args[3], 3) + ok(not orig_args) + + with_plugin:foo(1, nil, nil, nil, 5) + is(got_args.n, 5) + is(got_args[1], 1) + is(got_args[2], nil) + is(got_args[3], nil) + is(got_args[4], nil) + is(got_args[5], 5) + ok(not orig_args) +end -- }}} + +do -- exception tests {{{ + local with_plugin = clone:clone() + + local has_called_original + + function with_plugin:foo() + has_called_original = true + end + + with_plugin:loadplugin(function() + function override:foo() + error 'uh-oh' + end + end) + + local _, err = pcall(with_plugin.foo, with_plugin) + + like(err, 'uh%-oh') + ok(not has_called_original) +end -- }}} + +do -- return value tests {{{ + local with_plugin = clone:clone() + + function with_plugin:foo() + return 17 + end + + function with_plugin:bar() + return 18, 19, 20 + end + + function with_plugin:baz() + return 1, nil, nil, nil, 5 + end + + with_plugin:loadplugin(function() + function override:foo() + return 18 + end + + function override:bar() + return 19, 20, 21 + end + + function override:baz() + return 1, nil, nil, 4 + end + end) + + local result = with_plugin:foo() + is(result, 18) + + local results = utils.gather_results(with_plugin:bar()) + utils.cmp_tables(results, { n = 3, 19, 20, 21 }) + + results = utils.gather_results(with_plugin:baz()) + utils.cmp_tables(results, { n = 4, 1, nil, nil, 4 }) +end -- }}} + +do -- multiple advice, multiple plugins {{{ + local with_plugin = clone:clone() + local calls = {} + + function with_plugin:foo() + calls[#calls + 1] = 'original' + end + + with_plugin:loadplugin(function() + function override:foo() + calls[#calls + 1] = 'first' + end + end) + + with_plugin:loadplugin(function() + function override:foo() + calls[#calls + 1] = 'second' + end + end) + + with_plugin:foo() + + utils.cmp_tables(calls, { 'second' }) +end + +do -- multiple advice, single plugin {{{ + local with_plugin = clone:clone() + local calls = {} + + function with_plugin:foo() + calls[#calls + 1] = 'original' + end + + with_plugin:loadplugin(function() + function override:foo() + calls[#calls + 1] = 'first' + end + + function override:foo() + calls[#calls + 1] = 'second' + end + end) + + with_plugin:foo() + + utils.cmp_tables(calls, { 'second' }) +end diff --git a/lib/lua-repl/t/plugin-repl-tests.lua b/lib/lua-repl/t/plugin-repl-tests.lua new file mode 100644 index 00000000..b3aa7665 --- /dev/null +++ b/lib/lua-repl/t/plugin-repl-tests.lua @@ -0,0 +1,75 @@ +-- vim:foldmethod=marker +local r = require 'repl' -- we don't call it 'repl' so we don't shadow + -- repl in the plugin environment +pcall(require, 'luarocks.loader') +require 'Test.More' +local utils = require 'test-utils' + +plan(5) + +local clone = r:clone() + +do -- basic tests {{{ + local with_plugin = clone:clone() + + function with_plugin:foo() + end + + local line_no + + local _, err = pcall(function() + with_plugin:loadplugin(function() + line_no = utils.next_line_number() + function repl:foo() + end + end) + end) + + like(err, string.format("%d: The 'foo' method already exists", line_no)) + + with_plugin:loadplugin(function() + function repl:bar() + return 17 + end + end) + + is(with_plugin:bar(), 17) + + with_plugin:loadplugin(function() + repl.baz = 18 + end) + + is(with_plugin.baz, 18) +end -- }}} + +do -- conflict tests {{{ + local clone = r:clone() + local line_no + + clone:loadplugin(function() + function repl:foo() + end + end) + + local _, err = pcall(function() + clone:loadplugin(function() + line_no = utils.next_line_number() + function repl:foo() + end + end) + end) + + like(err, tostring(line_no) .. ": The 'foo' method already exists") +end -- }}} + +do -- proxy tests {{{ + local clone = r:clone() + + clone:loadplugin(function() + features = 'foo' + end) + + clone:loadplugin(function() + ok(repl:hasfeature 'foo') + end) +end -- }}} diff --git a/lib/lua-repl/t/sync-repl-tests.lua b/lib/lua-repl/t/sync-repl-tests.lua new file mode 100644 index 00000000..d5249ec2 --- /dev/null +++ b/lib/lua-repl/t/sync-repl-tests.lua @@ -0,0 +1,52 @@ +-- vim:foldmethod=marker +local sync = require 'repl.sync' +pcall(require, 'luarocks.loader') +require 'Test.More' + +plan(13) + +local clone = sync:clone() +local resultlist = {} + +function clone:lines() + local index = 0 + local function iterator(s) + index = index + 1 + return s[index] + end + + return iterator, { + 'return foo', + 'return 1', + 'return "bar"', + 'return {}', + 'return 1, 2, 3', + } +end + +function clone:showprompt() +end + +function clone:displayresults(results) + resultlist[#resultlist + 1] = results +end + +clone:run() + +is(#resultlist, 5) +is(resultlist[1].n, 1) +is(resultlist[1][1], nil) + +is(resultlist[2].n, 1) +is(resultlist[2][1], 1) + +is(resultlist[3].n, 1) +is(resultlist[3][1], 'bar') + +is(resultlist[4].n, 1) +is(type(resultlist[4][1]), 'table') + +is(resultlist[5].n, 3) +is(resultlist[5][1], 1) +is(resultlist[5][2], 2) +is(resultlist[5][3], 3) |