forks
/
arsd
mirror of https://github.com/adamdruppe/arsd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

5500 page omnibus bill no need to read this just vote for it

This commit is contained in:
Adam D. Ruppe 2020-12-28 10:57:20 -05:00
parent bbb56b2555
commit 0e0335da5c
14 changed files with 2327 additions and 1237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
cgi.d
View File

@ -333,12 +333,17 @@ void main() {
Copyright:
cgi.d copyright 2008-2019, Adam D. Ruppe. Provided under the Boost Software License.
cgi.d copyright 2008-2020, Adam D. Ruppe. Provided under the Boost Software License.
Yes, this file is almost ten years old, and yes, it is still actively maintained and used.
Yes, this file is old, and yes, it is still actively maintained and used.
+/
module arsd.cgi;
version(Demo)
unittest {
}
static import std.file;
// for a single thread, linear request thing, use:
@ -8037,6 +8042,16 @@ private bool hasIfCalledFromWeb(attrs...)() {
return false;
}
/++
Implies POST path for the thing itself, then GET will get the automatic form.
The given customizer, if present, will be called as a filter on the Form object.
History:
Added December 27, 2020
+/
template AutomaticForm(alias customizer) { }
/+
Argument conversions: for the most part, it is to!Thing(string).
@ -8170,6 +8185,10 @@ q"css
padding: 0px;
}
dl.automatic-data-display {
}
.automatic-form {
max-width: 600px;
}
@ -8185,6 +8204,10 @@ q"css
margin-left: -0.5em;
}
.submit-button-holder {
padding-left: 2em;
}
.add-array-button {
}
@ -8323,7 +8346,8 @@ html", true, true);
void presentExceptionAsHtmlImpl(Cgi cgi, Throwable t, Form automaticForm) {
if(auto mae = cast(MissingArgumentException) t) {
auto container = this.htmlContainer();
container.appendChild(Element.make("p", "Argument `" ~ mae.argumentName ~ "` of type `" ~ mae.argumentType ~ "` is missing"));
if(cgi.requestMethod == Cgi.RequestMethod.POST)
container.appendChild(Element.make("p", "Argument `" ~ mae.argumentName ~ "` of type `" ~ mae.argumentType ~ "` is missing"));
container.appendChild(automaticForm);
cgi.write(container.parentDocument.toString(), true);
@ -8474,6 +8498,8 @@ html", true, true);
auto form = cast(Form) Element.make("form");
form.method = "POST"; // FIXME
form.addClass("automatic-form");
string formDisplayName = beautify(__traits(identifier, method));
@ -8563,7 +8589,7 @@ html", true, true);
return Element.make("span", to!string(t), "automatic-data-display");
} else static if(is(T == V[K], K, V)) {
auto dl = Element.make("dl");
dl.addClass("automatic-data-display");
dl.addClass("automatic-data-display associative-array");
foreach(k, v; t) {
dl.addChild("dt", to!string(k));
dl.addChild("dd", formatReturnValueAsHtml(v));
@ -8571,12 +8597,12 @@ html", true, true);
return dl;
} else static if(is(T == struct)) {
auto dl = Element.make("dl");
dl.addClass("automatic-data-display");
dl.addClass("automatic-data-display struct");
foreach(idx, memberName; __traits(allMembers, T))
static if(__traits(compiles, __traits(getMember, T, memberName).offsetof)) {
dl.addChild("dt", memberName);
dl.addChild("dt", formatReturnValueAsHtml(__traits(getMember, t, memberName)));
dl.addChild("dt", beautify(memberName));
dl.addChild("dd", formatReturnValueAsHtml(__traits(getMember, t, memberName)));
}
return dl;
@ -8935,6 +8961,8 @@ private auto serveApiInternal(T)(string urlPrefix) {
static if(is(param : Cgi)) {
static assert(!is(param == immutable));
cast() params[pidx] = cgi;
} else static if(is(param == typeof(presenter))) {
cast() param[pidx] = presenter;
} else static if(is(param == Session!D, D)) {
static assert(!is(param == immutable));
cast() params[pidx] = cgi.getSessionObject!D();
@ -8973,12 +9001,16 @@ private auto serveApiInternal(T)(string urlPrefix) {
if(remainingUrl.length)
return false;
bool automaticForm;
foreach(attr; __traits(getAttributes, overload))
static if(is(attr == AddTrailingSlash)) {
if(remainingUrl is null) {
cgi.setResponseLocation(cgi.pathInfo ~ "/");
return true;
}
} else static if(__traits(isSame, AutomaticForm, attr)) {
automaticForm = true;
}
/+
@ -9054,10 +9086,18 @@ private auto serveApiInternal(T)(string urlPrefix) {
+/
if(callFunction)
+/
if(automaticForm && cgi.requestMethod == Cgi.RequestMethod.GET) {
// Should I still show the form on a json thing? idk...
auto ret = presenter.createAutomaticFormForFunction!((__traits(getOverloads, obj, methodName)[idx]))(&(__traits(getOverloads, obj, methodName)[idx]));
presenter.presentSuccessfulReturn(cgi, ret, presenter.methodMeta!(__traits(getOverloads, obj, methodName)[idx]), "html");
return true;
}
switch(cgi.request("format", defaultFormat!overload())) {
case "html":
// a void return (or typeof(null) lol) means you, the user, is doing it yourself. Gives full control.
try {
auto ret = callFromCgi!(__traits(getOverloads, obj, methodName)[idx])(&(__traits(getOverloads, obj, methodName)[idx]), cgi);
presenter.presentSuccessfulReturn(cgi, ret, presenter.methodMeta!(__traits(getOverloads, obj, methodName)[idx]), "html");
} catch(Throwable t) {
@ -9096,12 +9136,12 @@ private auto serveApiInternal(T)(string urlPrefix) {
}
}
}
case "script.js":
case "GET script.js":
cgi.setResponseContentType("text/javascript");
cgi.gzipResponse = true;
cgi.write(presenter.script(), true);
return true;
case "style.css":
case "GET style.css":
cgi.setResponseContentType("text/css");
cgi.gzipResponse = true;
cgi.write(presenter.style(), true);
@ -9139,6 +9179,8 @@ template urlNamesForMethod(alias method, string default_) {
string def = default_;
bool hasAutomaticForm = false;
foreach(attr; __traits(getAttributes, method)) {
static if(is(typeof(attr) == Cgi.RequestMethod)) {
verb = attr;
@ -9152,6 +9194,9 @@ template urlNamesForMethod(alias method, string default_) {
foundNoun = true;
def = attr.name;
}
static if(__traits(isSame, attr, AutomaticForm)) {
hasAutomaticForm = true;
}
}
if(def is null)
@ -9165,7 +9210,12 @@ template urlNamesForMethod(alias method, string default_) {
foreach(v; __traits(allMembers, Cgi.RequestMethod))
ret ~= v ~ " " ~ def;
} else {
ret ~= to!string(verb) ~ " " ~ def;
if(hasAutomaticForm) {
ret ~= "GET " ~ def;
ret ~= "POST " ~ def;
} else {
ret ~= to!string(verb) ~ " " ~ def;
}
}
} else static assert(0);
@ -9846,6 +9896,7 @@ auto serveStaticFileDirectory(string urlPrefix, string directory = null) {
return DispatcherDefinition!(internalHandler, DispatcherDetails)(urlPrefix, false, DispatcherDetails(directory));
}
// duplicated in http2.d
private static string getHttpCodeText(int code) pure nothrow @nogc {
switch(code) {
case 200: return "200 OK";
@ -9855,7 +9906,7 @@ private static string getHttpCodeText(int code) pure nothrow @nogc {
case 204: return "204 No Content";
case 205: return "205 Reset Content";
//
case 300: return "300 300 Multiple Choices";
case 300: return "300 Multiple Choices";
case 301: return "301 Moved Permanently";
case 302: return "302 Found";
case 303: return "303 See Other";

78
docs/dev_philosophy.d Normal file
View File

@ -0,0 +1,78 @@
// just docs: Development Philosophy
/++
This document aims to describe how things work here, what kind of bugs you can expect, how you can ask for new features, and my views on breaking changes and code organization.
You can read more in my (aspirationally) weekly blog here: http://dpldocs.info/this-week-in-d/Blog.html
$(H2 How it is developed)
This library is mostly developed as a means to an end for me. As such, it might work for you but might not since I usually do just what I need to do to get the job done then move on. I often focus on laying groundwork moreso than "completing" things, since then I can usually add things for myself pretty quickly as I go.
If you need something, feel free to contact me and I might be able to help code it up fairly quickly and get it to you, then I'll commit later for other people with similar needs.
$(H2 Code organization)
The arsd library is more like your public library than most software packages. Like a book library, there's no expectation that every module in here is actually useful to you - you should just browse the available modules and then only use the ones you need.
Modules usually aim to have as few dependencies as I can, often importing just one or two (or zero!) other modules from the repo. They almost never will import anything from outside this repo or the D standard library. This makes it easy for you to even just download a few individual files from here and use them without the others even being present.
$(H2 Breaking changes and versioning)
Typically, once I document something, I try hard to never break it. If I say you can "just download file.d", that's a commitment to never make it import anything else. If I break that commitment, I'll advertise it as a breaking change, add a note to the README file, and bump the package major version on the dub repo, even if nothing else is broken.
A add things regularly, but until they are documented in a tagged release, I make no promises it won't break. After it is though, I'll maintain it indefinitely (to the extent possible), unless I specifically say otherwise in the documentation comment.
$(H2 Licensing)
Everything in here is provided with no warranty of any kind, has no support contract whatsoever, and you assume full responsibility for using it.
Each file in here may be under a different license, since some of them are adopted ports of other people's code (if I do decide to use a library, I will adopt it and take responsibility for maintaining it myself to ensure our users never have to worry about third-party breakage). Some individual functions will import code with a different license, so you may choose not to use those functions. The documentation will call this out in those specific cases.
In some cases, different `-version` switches will compile in or version out code with different licenses. Your final result should be assumed to be under the most restrictive license included by any part. I will call this out in the documentation of the modules, if necessary.
If the documentation and/or source code comments don't say otherwise, you can assume all files are written by me and released under the Boost Software License, 1.0.
$(WARNING
dub's package format does not necessarily cover the nuance of optional functions. The documentation and copyright notices in the code are authoritative, not the dub package metadata.
)
Nothing in this repo will be licensed incompatibly with the GNU Affero GPL.
$(H2 FAQs)
$(H3 What does ARSD stand for?)
Adam Ruppe's Software Development. It was a fake company I made up in my youth and decided to keep the name here as it is generic enough to fit, but not so general it is easily confused with other people's projects.
$(H3 Why aren't all the modules on dub?)
dub is not really compatible with my development practices and is bolted on after-the-fact. Since dub requires so much redundant duplication and doesn't benefit me in general, I just haven't done the tedious busy work of filling in its forms for everything.
I generally accept pull requests though if you want to add one. Use the other subpackages as a template.
$(H3 Why no arsd/ or source/arsd subdirectories?)
The repo is $(I already) such a directory. Adding a second one is just a pointless complication. Similarly, the whole directory is source, no need to be redundant, and being redundant actually harms usability.
If you were to git clone to some directory, all the files here will be placed in their own directory automatically. If you then passed that parent directory as an argument to `dmd -I`, the files in here are found and can be used automatically. You can even clone other repos that use this same layout in there and have all these libraries available, with no complicated setup or build system.
If I had my way, ALL D projects would use this layout. It makes optional dependencies just work at no cost, C libraries are automatically linked in (thanks to `pragma(lib)`) as-needed, and there's no configuration required.
$(CONSOLE
$ mkdir libs
$ cd libs
$ git clone git://arsd
$ git clone git://whatever_else
$ dmd -i -I/path/to/libs anything.d # just works! On my computer, I aliased this to `dmdi`
)
That's the way I do things on my computer and it works beautifully. Any change now would break that flow without benefiting me at all.
$(H3 Why are there mixes of spaces and tabs in the code?)
I use tabs myself, but you can find several parts in the repo with spaces because I do not reject contributions over trivial style differences.
If I edit contributed code after merging it, I usually keep using the same style as the rest of that function, but sometimes my code editor automatically inserts something else. I don't really care.
+/
module arsd.docs.dev_philosophy;

7
docs/package.d Normal file
View File

@ -0,0 +1,7 @@
// just docs: Overviews, concepts, and tutorials
/++
This section of the documentation has bigger picture documents.
+/
module arsd.docs;

108
dub.json
View File

@ -81,6 +81,31 @@
"libs-posix": ["freetype", "fontconfig"],
"sourceFiles": ["nanovega.d", "blendish.d"]
},
{
"name": "gamehelpers",
"description": "Assorted game-related structs and algorithms",
"targetType": "library",
"dflags": ["-mv=arsd.gamehelpers=gamehelpers.d"],
"importPaths": ["."],
"sourceFiles": ["gamehelpers.d"]
},
{
"name": "joystick",
"description": "joystick reading for Windows XInput and Linux",
"targetType": "library",
"dflags": ["-mv=arsd.joystick=joystick.d"],
"importPaths": ["."],
"sourceFiles": ["joystick.d"]
},
{
"name": "fibersocket",
"description": "Phobos-based fiber socket async i/o subclass",
"targetType": "library",
"dflags": ["-mv=arsd.fibersocket=fibersocket.d"],
"importPaths": ["."],
"sourceFiles": ["fibersocket.d"]
},
{
"name": "email",
"description": "Email helper library, both sending MIME messages and parsing incoming mbox/maildir messages",
@ -90,6 +115,15 @@
"dflags": ["-mv=arsd.email=email.d"],
"sourceFiles": ["email.d"]
},
{
"name": "mailserver",
"description": "Bare-bones incoming-only smtp server",
"targetType": "library",
"importPaths": ["."],
"dependencies": {"arsd-official:email":"*"},
"dflags": ["-mv=arsd.mailserver=mailserver.d"],
"sourceFiles": ["mailserver.d"]
},
{
"name": "image_files",
"description": "Various image file format support - PNG read/write, JPEG, TGA, BMP, PCX, TGA, DDS read.",
@ -100,7 +134,8 @@
"arsd-official:png":"*",
"arsd-official:bmp":"*",
"arsd-official:svg":"*",
"arsd-official:jpeg":"*"
"arsd-official:jpeg":"*",
"arsd-official:imageresize":"*"
},
"dflags": [
"-mv=arsd.image=image.d",
@ -110,6 +145,67 @@
],
"sourceFiles": ["image.d", "targa.d", "pcx.d", "dds.d"]
},
{
"name": "imageresize",
"description": "Image resizer for color.d's MemoryImage",
"importPaths": ["."],
"dependencies": {
"arsd-official:color_base":"*"
},
"targetType": "library",
"dflags": ["-mv=arsd.imageresize=imageresize.d"],
"sourceFiles": ["imageresize.d"]
},
{
"name": "simpleaudio",
"description": "Simple audio+midi playback and capture for Windows and Linux",
"importPaths": ["."],
"targetType": "library",
"dflags": ["-mv=arsd.simpleaudio=simpleaudio.d"],
"sourceFiles": ["simpleaudio.d"]
},
{
"name": "midi",
"description": "midi file format classes",
"importPaths": ["."],
"targetType": "library",
"dflags": ["-mv=arsd.midi=midi.d"],
"sourceFiles": ["midi.d"]
},
{
"name": "nukedopl3",
"description": "nukedopl3 emulator port, required by simpleaudio's playEmulatedOpl3Midi functio",
"license": "GPL",
"importPaths": ["."],
"targetType": "library",
"dflags": ["-mv=arsd.nukedopl3=nukedopl3.d"],
"sourceFiles": ["nukedopl3.d"]
},
{
"name": "mp3",
"license": "GPL",
"description": "MP3 decoder. Required if you use simpleaudio's playMp3 function",
"importPaths": ["."],
"targetType": "library",
"dflags": ["-mv=arsd.mp3=mp3.d"],
"sourceFiles": ["mp3.d"]
},
{
"name": "vorbis",
"description": "Ogg vorbis decoder. Required if you use simpleaudio's playOgg function",
"importPaths": ["."],
"targetType": "library",
"dflags": ["-mv=arsd.vorbis=vorbis.d"],
"sourceFiles": ["vorbis.d"]
},
{
"name": "wav",
"description": "wav file format read and write",
"importPaths": ["."],
"targetType": "library",
"dflags": ["-mv=arsd.wav=wav.d"],
"sourceFiles": ["wav.d"]
},
{
"name": "svg",
"description": "Dependency-free partial SVG file format read support",
@ -187,6 +283,15 @@
"dflags": ["-mv=arsd.characterencodings=characterencodings.d"],
"sourceFiles": ["characterencodings.d"]
},
{
"name": "argon2",
"description": "Binding to the argon2 password hashing C library",
"targetType": "library",
"importPaths": ["."],
"libs": ["argon2"],
"dflags": ["-mv=arsd.argon2=argon2.d"],
"sourceFiles": ["argon2.d"]
},
{
"name": "cgi",
"description": "web server library with cgi, fastcgi, scgi, and embedded http server support",
@ -228,6 +333,7 @@
},
{
"name": "mysql",
"license":"GPL-2.0 or later",
"description": "MySQL client library. Wraps the official C library with my database.d interface.",
"targetType": "library",
"dependencies": {"arsd-official:database_base":"*"},

502
fibersocket.d Normal file
View File

@ -0,0 +1,502 @@
/++
Fiber-based socket i/o built on Phobos' std.socket and Socket.select without any other dependencies.
This is meant to be a single-threaded event-driven basic network server.
---
void main() {
auto fm = new FiberManager();
// little tcp echo server
// exits when it gets "QUIT" on the socket.
Socket listener;
listener = fm.listenTcp6(6660, (Socket conn) {
while(true) {
char[128] buffer;
auto ret = conn.receive(buffer[]);
// keeps the Phobos interface so...
if(ret <= 0) // ...still need to check return values
break;
auto got = buffer[0 .. ret];
if(got.length >= 4 && got[0 .. 4] == "QUIT") {
listener.close();
break;
} else {
conn.send(got);
}
}
conn.close();
});
// simultaneously listen for and echo UDP packets
fm.makeFiber( () {
auto sock = fm.bindUdp4(9999);
char[128] buffer;
Address addr;
while(true) {
auto ret = sock.receiveFrom(buffer[], addr);
if(ret <= 0)
break;
import std.stdio;
auto got = buffer[0 .. ret];
// print it to the console
writeln("Received UDP ", got);
// send the echo
sock.sendTo(got, addr);
if(got.length > 4 && got[0 .. 4] == "QUIT") {
break; // stop processing udp when told to quit too
}
}
}).call(); // need to call it the first time ourselves to get it started
// run the events. This keeps going until there are no more registered events;
// so when all registered sockets are closed or abandoned.
//
// So this will return when both QUIT messages are received and all clients disconnect.
import std.stdio;
writeln("Entering.");
fm.run();
writeln("Exiting.");
}
---
Note that DNS address lookups here may still block the whole thread, but other methods on `Socket` are overridden in the subclass ([FiberSocket]) to `yield` appropriately, so you should be able to reuse most existing code that uses Phobos' Socket with little to no modification. However, since it keeps the same interface as the original object, remember you still need to check your return values!
There's two big differences:
$(NUMBERED_LIST
* You should not modify the `blocking` flag on the Sockets. It is already set for you and changing it will... probably not hurt, but definitely won't help.
* You shouldn't construct the Sockets yourself, nor call `connect` or `listen` on them. Instead, use the methods in the [FiberManager] class. It will ensure you get the right objects initialized in the right way with the minimum amount of blocking.
The `listen` family of functions accept a delegate that is called per each connection in a fresh fiber. The `connect` family of functions can only be used from inside an existing fiber - if you do it in a connection handler from listening, it is already set up. If it is from your main thread though, you'll get an assert error unless you make your own fiber ahead of time. [FiberManager.makeFiber] can construct one for you, or you can call `new Fiber(...)` from `import core.thread.fiber` yourself. Put all the work with the connection inside that fiber so the manager can do its work most efficiently.
)
There's several convenience functions to construct addresses for you too, or you may simply do `getAddress` or `new InternetAddress` and friends from `std.socket` yourself.
$(H2 Conceptual Overview)
A socket is a common programming object for communication over a network. Phobos has support for the basics and you can read more about that in my blog socket tutorial: http://dpldocs.info/this-week-in-d/Blog.Posted_2019_11_11.html
A lot of things describe [core.thread.fiber.Fiber|fibers] as lightweight threads, and that's not wrong, but I think that actually overcomplicates them. I prefer to think of a fiber as a function that can pause itself. You call it like a function, you write it like a function, but instead of always completing and returning, it can [core.thread.fiber.Fiber.yield|yield], which is putting itself on pause and returning to the caller. The caller then has a chance to resume the function when it chooses to simply by [core.thread.fiber.Fiber.call|calling] it again, and it picks up where it left off, or the caller can [core.thread.fiber.Fiber.reset|reset] the fiber function to the beginning and start over.
Fiber-based async i/o thus isn't as complicated as it sounds. The basic idea is you just write an ordinary function in the same style as if you were doing linear, blocking i/o calls, but instead of actually blocking, you register a callback to be woken up when the call can succeed, then yield yourself. This callback you register is simply your own fiber resume method; the event loop picks up where you left off.
With Phobos sockets (and most Unix i/o functions), you then retry the operation that would have blocked and carry on because the callback is triggered when the operation is ready. If you're using another async system, like Windows' Overlapped I/O callbacks, it is actually even easier, since that callback happens when the operation has already completed. In those cases, you register the fiber's resume function as the event callback, then yield. When you wake up, you can immediately carry on.
When a fiber is woken up, it continues executing from the last `yield` call. Just think of `yield` as being a pause button you press.
Understanding how it works means you can translate any callback-based i/o system to use fibers, since it would always follow that same pattern: register the fiber resume method, then yield. If it is a callback when the operation is ready, try it again when you wake up (so right after yield, you can loop back to the call), or if it is a callback when the operation is complete, you can immediately use the result when you wake up (so right after yield, you use it).
How does the event loop work? How do you know what fiber runs next? See, this is where the "lightweight thread" explanation complicates things. With a thread, the operating system is responsible for scheduling them and might even run several simultaneously. Fibers are much simpler: again, think of them as just being a function that can pause itself. Like with an ordinary function, just one runs at a time (in your thread anyway, of course adding threads can complicate fibers like it can complicate any other function). Like with an ordinary function, YOU choose which one you want to call and when. And when a fiber `yield`s, it is very much like an ordinary function `return`ing - it passes control back to you, the caller. The only difference is the Fiber object remembers where the function was when it yielded, so you can ask it to pick up where it left off.
The event loop therefore doesn't look all that special. If you've used `Socket.select` before, you'll recognize most of it. (`select` can be tricky to use though, `epoll` based code is actually simpler and more efficient... but this module only wanted to use Phobos' std.socket on its own. Besides, `select` still isn't that complicated, is cross-platform, and performs well enough for most tasks anyway.) It has a list of active sockets that it adds to either a read or write set, it calls the select function, then it loops back over and handles the events, if set. The only special thing is the event handler resumes the fiber instead of some other action.
I encourage you to view the source of this file and try to follow along. It isn't terribly long and can hopefully help to introduce you to a new world of possibilities. You can use Fibers in other cases too, for example, the game I'm working on uses them in enemy scripts. It sets up their action, then yields and lets the player take their turn. When it is the computer's turn again, the script fiber resumes. Same principle, simple code once you get to know it.
$(H2 Limitations)
`Socket.select` has a limit on the number of pending sockets at any time, and since you have to loop through them each iteration, it can get slow with huge numbers of concurrent connections. I'd note that you probably will not see this problem, but it certainly can happen. Similarly, there's `new` allocations for each socket and virtual calls throughout, which, again, probably will be good enough for you, but this module is not C10K+ "web scale".
It also cannot be combined with other event loops in the same thread. But, since the [FiberManager] only uses the thread you give it, you might consider running it here and other things along side in their own threads.
Credits:
vibe.d is the first time I recall even hearing of fibers and is the direct inspiration for this.
History:
Written December 26, 2020. First included in arsd-official dub release 9.1.
License:
BSL-1.0, same as Phobos
+/
module arsd.fibersocket; // previously known as "centivibe" since it provides like 1/100th the functionality of vibe.d
public import std.socket;
import core.thread.fiber;
/// just because I forget how to enable this, trivial helper function
void allowBroadcast(Socket socket) {
socket.setOption(SocketOptionLevel.SOCKET, SocketOption.BROADCAST, 1);
}
/// Convenience function to loop and send until it it all sent or an error occurs.
ptrdiff_t sendAll(Socket s, scope const(void)[] data) {
auto ol = data.length;
while(data.length) {
auto ret = s.send(data);
if(ret <= 0)
return ret;
data = data[ret .. $];
}
return ol;
}
/++
Subclass of Phobos' socket that basically works the same way, except it yields back to the [FiberManager] when it would have blocked.
You should not modify the `blocking` flag on these and generally not construct them, connect them, or listen on them yourself (let [FiberManager] do the setup for you), but otherwise they work the same as the original Phobos [std.socket.Socket] and implement the very same interface. You can call the exact same functions with original Sockets or FiberSockets.
+/
class FiberSocket : Socket {
enum PendingOperation {
none, read, write
}
protected this(FiberManager fm) pure nothrow @safe {
this.fm = fm;
super();
}
/// You should probably call the helper functions in [FiberManager] instead.
this(FiberManager fm, AddressFamily af, SocketType st, Fiber fiber) {
assert(fm !is null);
this.fm = fm;
this.fiber = fiber;
super(af, st);
this.blocking = false;
}
void callFiber() {
fiber.call();
}
private FiberManager fm;
private Fiber fiber;
private PendingOperation pendingOperation;
private void queue(PendingOperation op) @trusted nothrow {
pendingOperation = op;
fm.pendingSockets ~= this;
fiber.yield();
}
protected override Socket accepting() pure nothrow {
return new FiberSocket(fm);
}
private ptrdiff_t magic(scope ptrdiff_t delegate() @safe what, PendingOperation op) @trusted {
try_again:
auto r = what();
if(r == -1 && wouldHaveBlocked()) {
queue(op);
goto try_again;
}
return r;
}
/// Yielding override of the Phobos interface
override ptrdiff_t send(const(void)[] buf, SocketFlags flags) {
return magic( () { return super.send(buf, flags); }, PendingOperation.write);
}
/// ditto
override ptrdiff_t receive(void[] buf, SocketFlags flags) {
return magic( () { return super.receive(buf, flags); }, PendingOperation.read);
}
/// ditto
override ptrdiff_t receiveFrom(void[] buf, SocketFlags flags, ref Address from) @trusted {
return magic( () { return super.receiveFrom(buf, flags, from); }, PendingOperation.read);
}
/// ditto
override ptrdiff_t receiveFrom(void[] buf, SocketFlags flags) @trusted {
return magic( () { return super.receiveFrom(buf, flags); }, PendingOperation.read);
}
/// ditto
override ptrdiff_t sendTo(const(void)[] buf, SocketFlags flags, Address to) @trusted {
return magic( () { return super.sendTo(buf, flags, to); }, PendingOperation.write);
}
/// ditto
override ptrdiff_t sendTo(const(void)[] buf, SocketFlags flags) @trusted {
return magic( () { return super.sendTo(buf, flags); }, PendingOperation.write);
}
// lol overload sets
/// The Phobos overloads are still available too, they forward to the overrides in this class and thus work the same way.
alias send = typeof(super).send;
/// ditto
alias receive = typeof(super).receive;
/// ditto
alias sendTo = typeof(super).sendTo;
/// ditto
alias receiveFrom = typeof(super).receiveFrom;
}
/++
The FiberManager is responsible for running your socket event loop and dispatching events to your fibers. It is your main point of interaction with this library.
Generally, a `FiberManager` will exist in your `main` function and take over that thread when you call [run]. You construct one, set up your listeners, etc., then call `run` and let it do its thing.
+/
class FiberManager {
private FiberSocket[] pendingSockets;
private size_t defaultFiberStackSize;
/++
Params:
defaultFiberStackSize = size, in bytes, of the fiber stacks [makeFiber] returns. If 0 (the default), use the druntime default.
+/
this(size_t defaultFiberStackSize = 0) {
this.defaultFiberStackSize = defaultFiberStackSize;
}
/++
Convenience function to make a worker fiber based on the manager's configuration.
This is used internally when connections come in.
+/
public Fiber makeFiber(void delegate() fn) {
return defaultFiberStackSize ? new Fiber(fn, defaultFiberStackSize) : new Fiber(fn);
}
/++
Convenience functions for creating listening sockets. These are trivial forwarders to [listenStream], constructing the appropriate [std.socket.Address] object for you. Note the address lookup does NOT at this time use the fiber io and may thus block your thread.
You can `close` the returned socket when you want to stop listening, or just ignore it if you want to listen for the whole duration of the program.
+/
final Socket listenTcp6(ushort port, void delegate(Socket) connectionHandler, int backlog = 8) {
return listenStream(new Internet6Address(port), connectionHandler, backlog);
}
/// ditto
final Socket listenTcp6(string address, ushort port, void delegate(Socket) connectionHandler, int backlog = 8) {
return listenStream(new Internet6Address(address, port), connectionHandler, backlog);
}
/// ditto
final Socket listenTcp4(ushort port, void delegate(Socket) connectionHandler, int backlog = 8) {
return listenStream(new InternetAddress(port), connectionHandler, backlog);
}
/// ditto
final Socket listenTcp4(string address, ushort port, void delegate(Socket) connectionHandler, int backlog = 8) {
return listenStream(new InternetAddress(address, port), connectionHandler, backlog);
}
/// ditto
version(Posix)
final Socket listenUnix(string path, void delegate(Socket) connectionHandler, int backlog = 8) {
return listenStream(new UnixAddress(path), connectionHandler, backlog);
}
/++
Core listen function for streaming connection-oriented sockets (TCP, etc.)
It will:
$(LIST
* Create a [FiberSocket]
* Create fibers on it for each incoming connection which call your `connectionHandler`
* Bind to the given `Address`
* Call `socket.listen(backlog)`
* Start `accept`ing connections.
)
Returns: the listening socket. You shouldn't do much with this except maybe `close` it when you are done.
+/
Socket listenStream(Address addr, void delegate(Socket) connectionHandler, int backlog) {
assert(connectionHandler !is null, "null connectionHandler passed to a listenTcp function");
FiberSocket socket;
socket = new FiberSocket(this, addr.addressFamily, SocketType.STREAM, makeFiber(
delegate() {
while(socket.isAlive()) {
socket.queue(FiberSocket.PendingOperation.read); // put fiber on hold until ready to accept
auto ns = cast(FiberSocket) socket.accept();
ns.blocking = false;
ns.fiber = makeFiber(delegate() {
connectionHandler(ns);
});
// need to get the new connection started
ns.fiber.call();
}
}
));
socket.setOption(SocketOptionLevel.SOCKET, SocketOption.REUSEADDR, true);
socket.bind(addr);
socket.blocking = false;
socket.listen(backlog);
socket.callFiber();
return socket;
}
/++
Convenience functions that forward to [connectStream] for the given protocol. They connect, send, and receive in an async manner, but do not create their own fibers - you must already be in one when you call this function.
Connections only work if you are already in a fiber. This is the case in a connectionHandler, but not from your main function. You'll have to make your own worker fiber. (But tbh if you only have one connection anyway, you might as well use a standard Socket.)
If you are already in a connection handler set in the listen family of functions, you're all set - those are automatically in fibers. If you are in main though, you need to make a worker fiber.
Making a worker fiber is simple enough. You can do it with `new Fiber` or with [FiberManager.makeFiber] (the latter just calls the former with a size argument set up in the FiberManager constructor).
---
auto fm = new FiberManager();
fm.makeFiber(() {
auto socket = fm.connectTcp4(...);
socket.send(...);
}).call(); // you must call it the first time yourself so it self-registers
---
OR
---
import core.thread.fiber;
auto fiber = new Fiber(() {
auto socket = fm.connectTcp4(...);
// do stuff in here
}).call(); // same deal, still need to call it the first time yourself to give it a chance to self-register
---
+/
final Socket connectTcp4(string address, ushort port) {
return connectStream(new InternetAddress(address, port));
}
/// ditto
final Socket connectTcp6(string address, ushort port) {
return connectStream(new Internet6Address(address, port));
}
/// ditto
version(Posix)
final Socket connectUnix(string path) {
return connectStream(new UnixAddress(path));
}
/++
Connects a streaming socket to the given address that will yield to this FiberManager instead of blocking.
+/
Socket connectStream(Address address) {
assert(Fiber.getThis !is null, "connect functions can only be used from inside preexisting fibers");
FiberSocket socket = new FiberSocket(this, address.addressFamily, SocketType.STREAM, Fiber.getThis);
socket.connect(address);
socket.queue(FiberSocket.PendingOperation.write); // wait for it to connect
scope(failure)
socket.close();
// and ensure the connection was successful before proceeding
int result;
if(socket.getOption(SocketOptionLevel.SOCKET, SocketOption.ERROR, result) < 0)
throw new Exception("get socket error failed");
if(result != 0)
throw new Exception("Connect failed");
return socket;
}
/++
These are convenience functions that forward to [bindDatagram].
UDP sockets don't connect per se, but the basically work the same as [connectStream]. See the caveat about requiring a premade Fiber from that page.
+/
Socket bindUdp4(string address, ushort port) {
return bindDatagram(new InternetAddress(address, port));
}
/// ditto
Socket bindUdp4(ushort port) {
return bindDatagram(new InternetAddress(port));
}
/// ditto
Socket bindUdp6(string address, ushort port) {
return bindDatagram(new Internet6Address(address, port));
}
/// ditto
Socket bindUdp6(ushort port) {
return bindDatagram(new Internet6Address(port));
}
/++
Only valid from inside a worker fiber, see [makeFiber].
---
fm.makeFiber(() {
auto sock = fm.bindDatagram(new InternetAddress(5555));
sock.receiveFrom(....);
}).call(); // remember to call it the first time or it will never start!
+/
Socket bindDatagram(Address address) {
assert(Fiber.getThis !is null, "bind datagram functions can only be used from inside preexisting fibers");
FiberSocket socket = new FiberSocket(this, address.addressFamily, SocketType.DGRAM, Fiber.getThis);
socket.bind(address);
return socket;
}
/++
Runs the program and manages the fibers and connections for you, calling the appropriate functions when new events arrive.
Returns when no connections are left open.
+/
void run() {
auto readSet = new SocketSet;
auto writeSet = new SocketSet;
while(true) {
readSet.reset();
writeSet.reset();
int added;
for(int idx = 0; idx < pendingSockets.length; idx++) {
auto pending = pendingSockets[idx];
if(!pending.isAlive()) {
// order not important here since we haven't done any real work yet
// really it shouldn't even be on the list.
pendingSockets[idx] = pendingSockets[$-1];
pendingSockets = pendingSockets[0 .. $-1];
pendingSockets.assumeSafeAppend();
idx--;
continue;
}
final switch(pending.pendingOperation) {
case FiberSocket.PendingOperation.none:
assert(0); // why is this object on this list?!
case FiberSocket.PendingOperation.write:
writeSet.add(pending);
added++;
break;
case FiberSocket.PendingOperation.read:
readSet.add(pending);
added++;
break;
}
}
if(added == 0)
return; // no work to do, all connections closed
auto eventCount = Socket.select(readSet, writeSet, null);//, 5.seconds);
if(eventCount == -1)
continue;
for(int idx = 0; idx < pendingSockets.length && eventCount > 0; idx++) {
auto pending = pendingSockets[idx];
SocketSet toCheck;
final switch(pending.pendingOperation) {
case FiberSocket.PendingOperation.none:
break;
case FiberSocket.PendingOperation.write:
toCheck = writeSet;
break;
case FiberSocket.PendingOperation.read:
toCheck = readSet;
break;
}
if(toCheck is null)
continue;
if(toCheck.isSet(pending)) {
eventCount--;
import std.algorithm.mutation;
// the order is fairly important since previous calls can append to
// this again, and we want to be sure we process the ones in this batch
// before seeing anything from the next batch.
pendingSockets = remove!(SwapStrategy.stable)(pendingSockets, idx);
pendingSockets.assumeSafeAppend();
idx--; // the slot we used to have is now different, so it needs to be reprocessed
pending.fiber.call();
}
}
}
}
}

3
gamehelpers.d
View File

@ -416,6 +416,9 @@ foreach(y; 0 .. size.height)
Point[4] neighborsBuffer;
int neighborsBufferLength = 0;
// FIXME: would be kinda cool to make this a more generic graph traversal like for subway routes too
if(current.x + 1 < size.width && isPassable(current + Point(1, 0)))
neighborsBuffer[neighborsBufferLength++] = current + Point(1, 0);
if(current.x && isPassable(current + Point(-1, 0)))

83
http2.d
View File

@ -1774,9 +1774,10 @@ class SimpleCache : ICache {
pre-populated will return a "server refused connection" response.
+/
class HttpMockProvider : ICache {
/++
/+ +
+/
version(none)
this(Uri baseUrl, string defaultResponseContentType) {
}
@ -1785,6 +1786,7 @@ class HttpMockProvider : ICache {
HttpResponse defaultResponse;
/// Implementation of the ICache interface. Hijacks all requests to return a pre-populated response or "server disconnected".
const(HttpResponse)* getCachedResponse(HttpRequestParameters request) {
import std.conv;
auto defaultPort = request.ssl ? 443 : 80;
@ -1801,7 +1803,7 @@ class HttpMockProvider : ICache {
return &defaultResponse;
}
// we never actually cache anything here since it is all about mock responses
/// Implementation of the ICache interface. We never actually cache anything here since it is all about mock responses, not actually caching real data.
bool cacheResponse(HttpRequestParameters request, HttpResponse response) {
return false;
}
@ -1829,7 +1831,7 @@ class HttpMockProvider : ICache {
HttpResponse r;
r.code = responseCode;
r.codeText = "Mocked"; // FIXME
r.codeText = getHttpCodeText(r.code);
r.content = cast(ubyte[]) response;
r.contentText = response;
@ -1837,6 +1839,7 @@ class HttpMockProvider : ICache {
population[request] = r;
}
version(none)
void populate(string method, string url, HttpResponse response) {
// FIXME
}
@ -1844,6 +1847,54 @@ class HttpMockProvider : ICache {
private HttpResponse[string] population;
}
// modified from the one in cgi.d to just have the text
private static string getHttpCodeText(int code) pure nothrow @nogc {
switch(code) {
// this module's proprietary extensions
case 0: return null;
case 1: return "request.abort called";
case 2: return "connection failed";
case 3: return "server disconnected";
case 4: return "exception thrown"; // actually should be some other thing
case 5: return "Request timed out";
// * * * standard ones * * *
// 1xx skipped since they shouldn't happen
//
case 200: return "OK";
case 201: return "Created";
case 202: return "Accepted";
case 203: return "Non-Authoritative Information";
case 204: return "No Content";
case 205: return "Reset Content";
//
case 300: return "Multiple Choices";
case 301: return "Moved Permanently";
case 302: return "Found";
case 303: return "See Other";
case 307: return "Temporary Redirect";
case 308: return "Permanent Redirect";
//
case 400: return "Bad Request";
case 403: return "Forbidden";
case 404: return "Not Found";
case 405: return "Method Not Allowed";
case 406: return "Not Acceptable";
case 409: return "Conflict";
case 410: return "Gone";
//
case 500: return "Internal Server Error";
case 501: return "Not Implemented";
case 502: return "Bad Gateway";
case 503: return "Service Unavailable";
//
default: assert(0, "Unsupported http code");
}
}
///
struct HttpCookie {
string name; ///
@ -2198,6 +2249,7 @@ version(use_openssl) {
}
}
/++
An experimental component for working with REST apis. Note that it
is a zero-argument template, so to create one, use `new HttpApiClient!()(args..)`
@ -2223,6 +2275,20 @@ version(use_openssl) {
args["body"] = "My cool PR is opened by the API!";
args.maintainer_can_modify = true;
/+
Fun fact, you can also write that:
var args = [
"title": "My Pull Request".var,
"head": "yourusername:" ~ branchName.var,
"base" : "master".var,
"body" : "My cool PR is opened by the API!".var,
"maintainer_can_modify": true.var
];
Note the .var constructor calls in there. If everything is the same type, you actually don't need that, but here since there's strings and bools, D won't allow the literal without explicit constructors to align them all.
+/
// this translates to `repos/dlang/phobos/pulls` and sends a POST request,
// containing `args` as json, then immediately grabs the json result and extracts
// the value `html_url` from it. `prUrl` is typed `var`, from arsd.jsvar.
@ -2253,9 +2319,16 @@ class HttpApiClient() {
urlBase = The base url for the api. Tends to be something like `https://api.example.com/v2/` or similar.
oauth2Token = the authorization token for the service. You'll have to get it from somewhere else.
submittedContentType = the content-type of POST, PUT, etc. bodies.
httpClient = an injected http client, or null if you want to use a default-constructed one
History:
The `httpClient` param was added on December 26, 2020.
+/
this(string urlBase, string oauth2Token, string submittedContentType = "application/json") {
httpClient = new HttpClient();
this(string urlBase, string oauth2Token, string submittedContentType = "application/json", HttpClient httpClient = null) {
if(httpClient is null)
this.httpClient = new HttpClient();
else
this.httpClient = httpClient;
assert(urlBase[0] == 'h');
assert(urlBase[$-1] == '/');

1214
image.d
View File

File diff suppressed because it is too large Load Diff

1214
imageresize.d Normal file
View File

File diff suppressed because it is too large Load Diff

189
mailserver.d Normal file
View File

@ -0,0 +1,189 @@
/++
A bare-bones, dead simple incoming SMTP server with zero outbound mail support. Intended for applications that want to process inbound email on a VM or something.
$(H2 Alternatives)
You can also run a real email server and process messages as they are delivered with a biff notification or get them from imap or something too.
History:
Written December 26, 2020, in a little over one hour. Don't expect much from it!
+/
module arsd.mailserver;
import arsd.fibersocket;
import arsd.email;
///
struct SmtpServerConfig {
//string iface = null;
ushort port = 25;
string hostname;
}
///
void serveSmtp(FiberManager fm, SmtpServerConfig config, void delegate(string[] recipients, IncomingEmailMessage) handler) {
fm.listenTcp4(config.port, (Socket socket) {
ubyte[512] buffer;
ubyte[] at;
const(ubyte)[] readLine() {
top:
int index = -1;
foreach(idx, b; at) {
if(b == 10) {
index = cast(int) idx;
break;
}
}
if(index != -1) {
auto got = at[0 .. index];
at = at[index + 1 .. $];
if(got.length) {
if(got[$-1] == '\n')
got = got[0 .. $-1];
if(got[$-1] == '\r')
got = got[0 .. $-1];
}
return got;
}
if(at.ptr is buffer.ptr && at.length < buffer.length) {
auto got = socket.receive(buffer[at.length .. $]);
if(got < 0) {
socket.close();
return null;
} if(got == 0) {
socket.close();
return null;
} else {
at = buffer[0 .. at.length + got];
goto top;
}
} else {
// no space
if(at.ptr is buffer.ptr)
at = at.dup;
auto got = socket.receive(buffer[]);
if(got <= 0) {
socket.close();
return null;
} else {
at ~= buffer[0 .. got];
goto top;
}
}
assert(0);
}
socket.sendAll("220 " ~ config.hostname ~ " SMTP arsd_mailserver\r\n"); // ESMTP?
immutable(ubyte)[][] msgLines;
string[] recipients;
loop: while(socket.isAlive()) {
auto line = readLine();
if(line is null) {
socket.close();
break;
}
if(line.length < 4) {
socket.sendAll("500 Unknown command");
continue;
}
switch(cast(string) line[0 .. 4]) {
case "HELO":
socket.sendAll("250 " ~ config.hostname ~ " Hello, good to see you\r\n");
break;
case "EHLO":
goto default; // FIXME
case "MAIL":
// MAIL FROM:<email address>
// 501 5.1.7 Syntax error in mailbox address "me@a?example.com.arsdnet.net" (non-printable character)
if(line.length < 11 || line[0 .. 10] != "MAIL FROM:") {
socket.sendAll("501 Syntax error");
continue;
}
line = line[10 .. $];
if(line[0] == '<') {
if(line[$-1] != '>') {
socket.sendAll("501 Syntax error");
continue;
}
line = line[1 .. $-1];
}
string currentDate; // FIXME
msgLines ~= cast(immutable(ubyte)[]) ("From " ~ cast(string) line ~ " " ~ currentDate);
msgLines ~= cast(immutable(ubyte)[]) ("Received: from " ~ socket.remoteAddress.toString);
socket.sendAll("250 OK\r\n");
break;
case "RCPT":
// RCPT TO:<...>
if(line.length < 9 || line[0 .. 8] != "RCPT TO:") {
socket.sendAll("501 Syntax error");
continue;
}
line = line[8 .. $];
if(line[0] == '<') {
if(line[$-1] != '>') {
socket.sendAll("501 Syntax error");
continue;
}
line = line[1 .. $-1];
}
recipients ~= (cast(char[]) line).idup;
socket.sendAll("250 OK\r\n");
break;
case "DATA":
socket.sendAll("354 Enter mail, end with . on line by itself\r\n");
more_lines:
line = readLine();
if(line == ".") {
handler(recipients, new IncomingEmailMessage(msgLines));
socket.sendAll("250 OK\r\n");
} else if(line is null) {
socket.close();
break loop;
} else {
msgLines ~= line.idup;
goto more_lines;
}
break;
case "QUIT":
socket.sendAll("221 Bye\r\n");
socket.close();
break;
default:
socket.sendAll("500 5.5.1 Command unrecognized\r\n");
}
}
});
}
version(Demo)
void main() {
auto fm = new FiberManager;
fm.serveSmtp(SmtpServerConfig(9025), (string[] recipients, IncomingEmailMessage iem) {
import std.stdio;
writeln(recipients);
writeln(iem.subject);
writeln(iem.textMessageBody);
});
fm.run;
}

2
package.d
View File

@ -5,6 +5,8 @@
You can usually use them independently, with few or no dependencies,
so it is easy to use raw, or you can use dub packages as well.
See [arsd.docs] for top-level documents in addition to what is below.
What are you working with? (minimal starting points now but im working on it)
${RAW_HTML

34
simpleaudio.d
View File

@ -208,6 +208,11 @@ interface SampleController {
Reports the current stream position, in seconds, if available (NaN if not).
+/
float position();
/++
If the sample has finished playing. Happens when it runs out or if it is stopped.
+/
bool finished();
}
private class DummySample : SampleController {
@ -215,17 +220,20 @@ private class DummySample : SampleController {
void resume() {}
void stop() {}
float position() { return float.init; }
bool finished() { return true; }
}
private class SampleControlFlags : SampleController {
void pause() { paused = true; }
void resume() { paused = false; }
void stop() { stopped = true; }
void stop() { paused = false; stopped = true; }
bool paused;
bool stopped;
bool finished_;
float position() { return currentPosition; }
bool finished() { return finished_; }
float currentPosition = 0.0;
}
@ -531,13 +539,17 @@ final class AudioPcmOutThreadImplementation : Thread {
return true;
}
if(!player.playing)
if(!player.playing) {
scf.finished_ = true;
return false;
}
auto pos = player.generate(buffer[]);
scf.currentPosition += cast(float) buffer.length / SampleRate/ channels;
if(pos == 0)
if(pos == 0 || scf.stopped) {
scf.finished_ = true;
return false;
}
return !scf.stopped;
}
);
@ -593,10 +605,13 @@ final class AudioPcmOutThreadImplementation : Thread {
return true;
}
scf.finished_ = true;
return false;
} else {
scf.currentPosition += cast(float) got / v.sampleRate;
}
if(scf.stopped)
scf.finished_ = true;
return !scf.stopped;
}
);
@ -692,11 +707,14 @@ final class AudioPcmOutThreadImplementation : Thread {
goto more;
} else {
buffer[] = 0;
scf.finished_ = true;
return false;
}
}
}
if(scf.stopped)
scf.finished_ = true;
return !scf.stopped;
}
);
@ -3802,8 +3820,10 @@ abstract class ResamplingContext {
if(outputChannels == 1) {
foreach(ref s; buffer) {
if(resamplerDataLeft.dataOut.length == 0) {
if(loadMore())
if(loadMore()) {
scflags.finished_ = true;
return false;
}
}
if(inputChannels == 1) {
@ -3821,8 +3841,10 @@ abstract class ResamplingContext {
} else if(outputChannels == 2) {
foreach(idx, ref s; buffer) {
if(resamplerDataLeft.dataOut.length == 0) {
if(loadMore())
if(loadMore()) {
scflags.finished_ = true;
return false;
}
}
if(inputChannels == 1) {
@ -3843,6 +3865,8 @@ abstract class ResamplingContext {
scflags.currentPosition += cast(float) buffer.length / outputSampleRate / outputChannels;
} else assert(0);
if(scflags.stopped)
scflags.finished_ = true;
return !scflags.stopped;
}
}

10
simpledisplay.d
View File

@ -7515,7 +7515,15 @@ struct ScreenPainter {
return impl.textSize(text);
}
///
/++
Draws a string in the window with the set font (see [setFont] to change it).
Params:
upperLeft = the upper left point of the bounding box of the text
text = the string to draw
lowerRight = the lower right point of the bounding box of the text. If 0, 0, there is no lower right bound.
alignment = A [arsd.docs.general_concepts#bitflags|combination] of [TextAlignment] flags
+/
@scriptable
void drawText(Point upperLeft, in char[] text, Point lowerRight = Point(0, 0), uint alignment = 0) {
if(impl is null) return;

47
terminal.d
View File

@ -64,19 +64,17 @@
+/
module arsd.terminal;
import core.stdc.stdio;
// FIXME: needs to support VT output on Windows too in certain situations
// detect VT on windows by trying to set the flag. if this succeeds, ask it for caps. if this replies with my code we good to do extended output.
/++
$(H3 Get Line)
This example will demonstrate the high-level getline interface.
This example will demonstrate the high-level [Terminal.getline] interface.
The user will be able to type a line and navigate around it with cursor keys and even the mouse on some systems, as well as perform editing as they expect (e.g. the backspace and delete keys work normally) until they press enter. Then, the final line will be returned to your program, which the example will simply print back to the user.
+/
version(demos) unittest {
unittest {
import arsd.terminal;
void main() {
@ -85,7 +83,7 @@ version(demos) unittest {
terminal.writeln("You wrote: ", line);
}
main; // exclude from docs
version(demos) main; // exclude from docs
}
/++
@ -94,7 +92,7 @@ version(demos) unittest {
This example demonstrates color output, using [Terminal.color]
and the output functions like [Terminal.writeln].
+/
version(demos) unittest {
unittest {
import arsd.terminal;
void main() {
@ -105,7 +103,7 @@ version(demos) unittest {
terminal.writeln("And back to normal.");
}
main; // exclude from docs
version(demos) main; // exclude from docs
}
/++
@ -114,7 +112,7 @@ version(demos) unittest {
This shows how to get one single character press using
the [RealTimeConsoleInput] structure.
+/
version(demos) unittest {
unittest {
import arsd.terminal;
void main() {
@ -126,7 +124,7 @@ version(demos) unittest {
terminal.writeln("You pressed ", ch);
}
main; // exclude from docs
version(demos) main; // exclude from docs
}
/*
@ -167,6 +165,7 @@ version(demos) unittest {
+/
__gshared void delegate() nothrow @nogc sigIntExtension;
import core.stdc.stdio;
version(TerminalDirectToEmulator) {
version=WithEncapsulatedSignals;
@ -1380,7 +1379,13 @@ struct Terminal {
// lazily initialized and preserved between calls to getline for a bit of efficiency (only a bit)
// and some history storage.
LineGetter lineGetter;
/++
The cached object used by [getline]. You can set it yourself if you like.
History:
Documented `public` on December 25, 2020.
+/
public LineGetter lineGetter;
int _currentForeground = Color.DEFAULT;
int _currentBackground = Color.DEFAULT;
@ -1465,7 +1470,7 @@ struct Terminal {
}
}
/// Changes the current color. See enum Color for the values.
/// Changes the current color. See enum [Color] for the values and note colors can be [arsd.docs.general_concepts#bitmasks|bitwise-or] combined with [Bright].
void color(int foreground, int background, ForceOption force = ForceOption.automatic, bool reverseVideo = false) {
if(force != ForceOption.neverSend) {
version(Win32Console) {
@ -2090,9 +2095,23 @@ struct Terminal {
_cursorY = 0;
}
/// gets a line, including user editing. Convenience method around the LineGetter class and RealTimeConsoleInput facilities - use them if you need more control.
/// You really shouldn't call this if stdin isn't actually a user-interactive terminal! So if you expect people to pipe data to your app, check for that or use something else.
// FIXME: add a method to make it easy to check if stdin is actually a tty and use other methods there.
/++
Gets a line, including user editing. Convenience method around the [LineGetter] class and [RealTimeConsoleInput] facilities - use them if you need more control.
$(TIP
You can set the [lineGetter] member directly if you want things like stored history.
---
Terminal terminal = Terminal(ConsoleOutputType.linear);
terminal.lineGetter = new LineGetter(&terminal, "my_history");
auto line = terminal.getline("$ ");
terminal.writeln(line);
---
)
You really shouldn't call this if stdin isn't actually a user-interactive terminal! So if you expect people to pipe data to your app, check for that or use something else. See [stdinIsTerminal].
+/
string getline(string prompt = null) {
if(lineGetter is null)
lineGetter = new LineGetter(&this);