Friday JS: reqyire.js and ochepyatko-oriented programming

And again, I welcome the respected habrizhitel in his not so constant, but repetitive heading. Today we will talk about how to become a more effective programmer under Node.js. And also, as you might guess from the title, about typos and their role in this process. Some code to attract attention.

const reqyire = require("reqyire"); const http = reqyire("htpp"); const server = http.creteServer((req, res) => { res.statusCode = 200; res.setHeader('Content-Type', 'text/plain'); res.end('Hello World\n'); }); server.listem(3000, "127.0.0.1"); 

Perhaps it would not be an exaggeration to say that typos are the scourge and plague of programming. A huge amount of resources goes to fight them. Wool code ingenious static analyzers, spending precious seconds of working time; IDE autocompletion, mercilessly devouring processor cycles, prompts the correct, in his opinion, options. The compiler refuses to compile, and the interpreter refuses to interpret the code where some pitiful letter is missing or replaced. Even a no-brainer that "creteServer" is "createServer" with the missing letter "a". But the V8 engine is not a hedgehog, and it swears at this harmless slip of its merciless "undefined is not a function".

And once I wondered: maybe we are doing something wrong? Perhaps, what we are fighting with as an enemy can become our ally and servant? The result of these reflections was the library reqyire.js , which, I hope, will forever change the world of server-side JS programming.
')

Instructions for use

To begin with, of course, you need to install the library:

 npm install reqyire 

After that, at the beginning of each file where you plan to use it, write:

 const reqyire = require("reqyire"); 

In the future, use reqyire instead of require when there are concerns that you can make a typo in the module name. That is always. No more will you have to see endless “Error: cannot find module” - reqyire will definitely find you a module. The following code:

 const reqyire = require("reqyire"); const path = reqyire("pah"), fs = reqyire("fds"), util = reqyire("./disrt/ytil.js"); 

- will work, and work as it should, and not as written.

If you have a fairly recent version of Node.js (or not quite fresh, but launched with the --harmony-proxies flag), then wonders will not end there. Thanks to the magic of fresh JavaScript standards, all objects requested through reqyire also become comprehensible and allow you to make typos in the names of their properties. This intelligence is also passed to child objects, and even to objects returned by functions:

 const path = reqyire("pat"), fs = reqyire("fd"); var folder = path.win33.dirmame(".\\Works\\perfectly\\correct\\index.js"); fs.stasSync(folder).isDyrectori(); // true 

If some object does not have the happiness of being called through reqyire , but you still want to make him understand, reqyire.wrap comes to the rescue :

 var obj = {prop: "The internet is for"}; var wrappedObj = reqyire.wrap(obj); console.log(wrappedObj.porn, "porn"); 

Also reqyire.wrop , reqyire.warp , and indeed any method name, even remotely similar to wrap, will do.

Now that you have reqyire.js , you can spend less time correcting typos. This will allow you to write more lines of code per day and, obviously, make you a more effective programmer.

Disclaimer

Have you noticed the Sarcasm sign ? Of course, the words about improving efficiency, like the library itself, in principle, are not serious. Anyone who decides to use it in production will be cold in the ice hell of Helheim.

How it works?

It is unlikely that this question has arisen in experienced professionals, but the answer may come in handy to less sophisticated readers. Well, I'll be happy to explain everything, and don't even try to stop me.

Fuzzy search

The heart of the whole library is the function fuzzySearch (arrayOfStrings, string) . It finds in the array of strings the one between which and the second argument is the lowest Levenshtein distance , i.e. which requires the smallest number of operations to add, delete, or change a character to turn one into another. This is done using a slightly modified Wagner-Fisher algorithm . Instead of honestly counting the distance for each pair of lines, we memorize the smallest distance already found and stop the algorithm if the distance for a new line is obviously greater.

Generally speaking, Levenshtein distance is not the most appropriate metric. According to the mind, it would be worthwhile to use the distance of Damerau-Levenshtein , which is better suited to the nature of typos made by man. But, as the anecdote wrote in his course hero: "... I took wooden electrodes, because no one will read it anyway."

Search for modules

In order to use fuzzy search, you must first get an array of options from somewhere. First we look at the name of the requested module. According to the specification of the “native” function require , if the name starts with "/", "./" or "../", then this is the path to the file, otherwise it is the name of the installed module. Let's start with the second case, it's easier.

Installed modules are of three types: local, global and embedded. The list of the first and second can be obtained using console commands:

 npm ls -json npm ls -g -json 

For the third category, to my convenience, a suitable library was found. Combining these lists, we cache the result (the first two teams work long enough) and go through it with a fuzzy search.

File search

In the case of the file path there are two problems, obvious and less obvious. An obvious problem: the system may have (and most likely will) an astronomical number of files. Collecting an array of their locations, and then doing a fuzzy search on it is a very expensive operation. Thinking over my head, I came up with the following solution: we divide the path into elementary fragments (a sequence of directory names and a file name at the end) and we will not clearly search for each of these fragments, gradually forming the final path. Thus, reqyire ("./ jd / sctipr.js") will find the file "./js/script.js", but not the file "./jdsctipr.js".

A less obvious (perhaps only for me) problem was relative paths. To resolve an absolute path in the way that would have required, reqyire.js must know the absolute path to the script from which reqyire was called. It is impossible to recognize it using standard JS tools. I was about to give up, but, fortunately, I found a dirty hack related to the features of the V8 engine and allowing me to pull out the path to the calling script from the glasstrack.

Healing Wraps

As you might guess, the "intelligibility" is achieved using the ES6 Proxy . By wrapping an object in Proxy, you can intercept calls to its properties, call it as a function, and also many other amazing things, which, however, are less interesting for us now. The wrapper written by me produces a fuzzy search in the properties of the object if the property with the exact name does not exist. If the return result is an object, it is packaged in the same wrapper. The result of the function call is also packed.

Conclusion

Despite the practical uselessness of this library, its development was not useless. In the process, I learned a lot of new and interesting. I hope for you this post also proved to be informative. I will take my leave.