Hey, guys I just joined to ask this please forgive me if I am in the wrong place.
First of all big fan of bash, I use it a LOT 🚀. It would be fantastic if there was a nicer way to source files from the same folder instead of copy-pasting complicated logic in every script. Perhaps something similar to PHP's __DIR__ and __FILE__ constants? ``` source "$__DIR/file.ext" #$__DIR == the absolute path to the current scripts location. ``` I am aware there are existing bash mechanisms to achieve this but are cumbersome to use. USE CASE: I've been building myself a little ecosystem with hundreds of bash scripts. Its really handy to have the script's source and call each other without doing path resolving gymnastics in every single script. To make it nice to rapidly build scripts at will I have been putting common code into smaller scripts. And to solve the problem of easily sourcing them I just shoved them in my path lol. This lets me use a nice clean syntax like so: ``` #!/usr/bin/env bash source error-handler source colours #etc.. ``` While this makes including common files an absolute breeze it's not ideal to have all of them in my path because: - my sourceables also need logic to prevent them from being executed by accident (they tell you to source them instead). - I cant just share my script collection with colleagues because it will all break unless they add ALL my scripts to their system path and they might not want to do that. - all of the scripts call on each other and that also only works if the executables are in the system path. Defining a ton of functions and shoving them into peoples running environment is not an answer for me either lol. A shorthand to call them from the relative path would be immensely helpful for using bash scripting as a way to build suites of developer tools. ADDITIONAL FEATURE: This might be a little far fetch but, now that I think about it. A pseudo namespacing feature would be way handier, hear me out... Let's say you have a namespace keyword followed by the __DIR__ shorthand. And once that is done it will treat that folder as if it is at the front of the PATH var for the duration of the script. Then we can call upon all the local resources in the distributed scripts collection without jumping through hoops: ``` namespace $__DIR #$PATH = "$__DIR:$PATH" for the duration of the script. source error-handler DATA=some-common-command-in-my-library # etc.. ``` This would also mean that it can be easy to add a wrapper command to a collection of scripts named after the vendor so that, instead of directly calling from a collection of 300 scripts or adding them all to your path, you can simply add the one parent script to your path that namespaces and then calls all the others while providing bash completions etc. FOOTNOTE: I am aware I could already do this with existing bash mechanisms there is always a way. But, it's usually a hacky way I can't remember and always have to copy from an old script or look it up again and sometimes these hacks are not going to work on other systems. (talking in general not just about path resolving here now). I just feel we should be able to have some basic language features to make bash scripting better in general and being able to easily include code from your own folder would be a significant step up. Thanks for reading all this hope it makes sense.