Free improve shell scripting software for linux

MirBSD Korn Shell (mksh) is an actively developed successor of pdksh (the Public Domain Korn Shell), aimed at producing a shell good for interactive use, but with primary focus on scripting.
The project is intended to be portable to most *nix-like operating systems as long as theyre not too obscure. mksh incorporates improvements from OpenBSD and Debian, as well as bugfixes and enhancements developed for the MirOS and FreeWRT projects. The emacs command line editing mode is UTF-8 capable.
The shell supports large files, as well as all pdksh and some csh, AT&T ksh, and GNU bash features, is compatible with the Bourne shell (within limits, but you can turn off brace expansion), has no limit on array sizes, and incorporates some other useful builtins and features. While being already fast and small (without losing functionality), flags to make it even smaller can be given at compile time. An interactive shell reads "~/.mkshrc" on startup.
Enhancements:
- Packagers should read the information at http://www.mirbsd.org/mksh.htm#upgrade.
- mksh can now be built on more platforms, such as AIX, and with a lot of vendor compilers (Intel, Sun, IBM, Microsoft, Borland, Digital Mars, HP) in addition to gcc.
- Some constructs from GNU bash are supported.
- The code and build system got cleaned up, fixed, and improved further.
- Large file support on some OSes and POSIX compatibility got better.

Business Shell (BUSH) can be used as interactive command shell, scripting language with a source code debugger, a database client and a web template engine. With third-party support for the ABEE standard for Java Virtual Machine and .Net, BUSH is an all-in-one replacment for BASH, PHP, J2EE, Ruby, Python, PERL and PSQL.
There are many shells, interpreters and languages available. Virtually without exception, they are incompatible with one another. Whats the point of learning a tool that, no matter how sophisticated it is, leaves your source code stuck with that particular tool. You want to do scripting, so you use Python or Scheme.
You want to do reporting, so you use Perl. You want to write a script, so you use Bash. You want to write an applet, so you use Java. To be a programmer these days, you need to be fluent in a dozen different languages. You would be making more money if you got a job at the United Nations.
The Business Shell is different. Its based on a language called AdaScriptTM, a subset of one of the most powerful languages available for Linux today. Ada 95 is a GCC supported language so any project you write in Bush is immediately portable to any machine that GCC runs on. In other words, virtually everything.
And it means that Bush scripts can be compiled using GCC and everyone knows that GCC is superior to most commercial compilers. If thats not enough, using the JGNAT open source compiler, you can even compile your Bush scripts into actual Java bytecode. There is another tool, A#, that will compile scripts into .NET byte code Things dont get much more platform-independent than that.
But Bush does more than just create scripts, executable programs and Java applets. Its a powerful computer language on its own able to do complex math, manipulate files, generate reports and able to do network programming. Bush will let strings grow as big as you need without worry of a running out of buffer space. And a number of built-in packages will let you do everything from compute trig functions to connecting to a web server.
But best of all, Bush is easy. Perl claims to be easy. Easily like riding a bicycle backwards in the middle of a thunderstorm. Bush is easy to read, easy to understand. You know exactly what a script does without having to have a reference book beside you at all times
Bush doesnt run your programs outright. First it examines them, compresses them, and converts them into intermediate code. (Thats "byte code", to you Java developers.) Bush optimizes the program for the best possible performance. It also takes the time to verify your program will run before attempting to execute the first line.
And if you make to typing mistake, Bush will let you know before running your program. Theres no need to worry that your typo will be a valid command like it would be in most other languages. Bush works for you, not against you.
One tool for all solutions.
Main features:
- Internal Byte Code
- 200+ Built-in Functions
- Template Engine
- PostgreSQL DBI
- TCP/IP Sockets
- CGI Library
- AU/WAV Sound
- Arrays
- Records (Structures)
- Enumerated Types
- True Booleans
- Types and Subtypes
Enhancements:
- A new built-in directory_operations package.
- A serious memory leak problem with pragma prompt_script has been repaired.

Rains PPP scripts are a set of tools that simplify the use and setup of pppd.
Features include connection time logging, a ppp-off that works right with more than one pppd running, dial-on-demand support for pppd 2.3.x., and more.
Another interesting feature is that the scripts keep track of your connect speed and time, and included is an mirc script to show connection status from a remote machine, as well as a shell script that works for *IX boxes.
Enhancements:
- Made TTL for dyn.db 60 seconds
- --bootup should have been --quiet in ppp-on
- Fixed POSTLOGINSTRING
- Now using low-ascii in the README and ppp-on
- Re-fixed permission problems on /etc/inet.status (I hope)
- Fixed more spelling/grammar

CD Shell is a scriptable menu system that provides the ability to create interactive multi-boot optical discs. It will make PC-bootable compact discs or DVDs that can select from several program loaders or kernels located on the disc, or boot from other local disk drives that are attached to the system.
This utility is based heavily on concepts pioneered by Bart Lagerweij in his great program Diskem1x. CD Shell provides similar functionality to Diskem1x along with many new original features, such as an advanced scripting language, graphics, and mouse support. It also has the ability to interface with other great programs such as isolinux/memdisk, Ranish Partition Manager, and Memtest86+.
CD Shell is free for non-commercial use. The program and its source code is distributed under the NASM License. The distribution and use of some optional components is restricted by their respective licenses.
Enhancements:
- changed behavior of display.message to interpret a backslash as a single-character quote if not recognized as an escape sequence (suggested by Erwin Veermans of the Ultimate Boot CD project)
- isolinux patches as suggested by Charles Appel of the Ultimage Boot CD project
- patched a bug in isolinux that would display some garbage characters when loading a kernel (just before Ready)
- changed behavior for the display command to not show a splash screen unless isolinux was invoked with an empty command line
- incorporated changes to chooser script
- allow onEscape action when user quits the menu
- allow per-item exececute-on-select commands
- fixed a bug where text in the message window wasnt being updated correctly

Fry::Shell is a flexible shell framework which encourages using loadable libraries of functions.
SYNOPSIS
From the commandline: perl -MFry::Shell -eshell
OR
In a script:
package MyShell;
use Fry::Shell;
#subs
sub evalIt {
my $cls = shift;
my $code = ($cls->Flag(strict)) ? use strict; : ;
$code .= "@_";
eval "$code";
}
sub listStations {
my $cls = shift;
my @stations = ( {name=>high energy trance/techno,ip=>http://64.236.34.196:80/stream/1003},
{name=>macondo salsa,ip=>http://165.132.105.108:8000},
{name=>new age,ip=>http://64.236.34.67:80/stream/2004},
);
$cls->saveArray(map{$_->{ip}} @stations);
return map {$_->{name}} @stations;
}
#set shell prompt
my $prompt = "Clever prompt: ";
#initialize shell and load a command and an option
my $sh = Fry::Shell->new(prompt=>$prompt,
load_obj=>{ cmds=>{listStations=>{a=>lS}},
opts=>{strict=>{type=>flag,a=>n,default=>0}} }
);
#begin shell loop
$sh->shell(@ARGV);
####end of example, start of other possible methods
#run shell once
$sh->once(@ARGV);
#loads libraries and runs each librarys &_initLib
$sh->initLibs(@modules);
$sh->loadFile($file);
$sh->loadPlugins($myplugin);
$sh->runCmd($cmd);
Fry::Shell is a simple and flexible way to create a shell. Unlike most other light-weight shells, this module facilitates (un)loading libraries of functions and thus encourages creating shells tailored to several modules. Although the shell is currently only viewable at the commandline, the framework is flexible enough to support other views (especially a web one. This module is mainly serving(will serve) as the model in an MVC framework.
From a user perspective it helps to know that a shell session consists of mainly four shell components (whose classes are known as core classes) : libraries (lib), commands (cmd), options (opt) and variables(var). Commands and options are the same as in any shell environment: a command mapping to a function and an option changing the behavior of a command ie changing variables within it or calling functions before the command. Variables store all the configurable data, including data relating to these commands and options. Libraries are containers for a related group of these components.
Main features:
- Loading/unloading shell components at runtime.
- Flexible framework for using shell features via plugins. You can even set up a bare minimum shell needing no external modules! Currently plugins exist for dumping data,readline support,reading shell configurations and viewing shell output.
- Commands and options can be aliased for minimal typing at the commandline.
- Commands can have help and usage defined.
- Commands can have user-defined argument types. One defines argument types by subroutines or tests that they should pass. These tests are then applied to a commands defined argument(s). With defined argument types, one can also define autocompletion routines for a commands arguments.
- Options can modify variables. Since variables exist for almost every aspect of the shell, options can change many core shell functions. A handy example is parsecmd which names the current parse subroutine for the current line. Changing this var would change how the input after the options is parsed.
- Options can have different behaviors defined including the ability to invoke subroutines when called or to maintain a value for a specified amount of iterations.
- Default options include menu which numbers output and allows the next command to reference them by number.
- Page output with preferred pager.
- Multiline mode.
- Comes with a decent default library,Fry::Lib::Default, to dump,list or unload any shell component, run system commands,evaluate perl statements and execute methods of autoloaded libraries.

JSON::Shell is an interactive shell for performing JSON and JSON-RPC requests.

SYNOPSIS

$ bin/jsonshell

JSON::Shell 1.0
www.example.com/json-rpc-demo$ post { "id": 1, "method": "echoObject", "params": { "o": [ "YAY JSON~" ] } }
REQUEST: $VAR1 = {
params => {
o => [
YAY JSON~
]
},
method => echoObject,
id => 1
};

RESPONSE: $VAR1 = {
id => 1,
result => [
YAY JSON~
]
};

www.example.com/json-rpc-demo$

JSON::Shell provides an interactive debugger and workbench for JSON based web services.

Simple Backup is a shell script to create basic backups using tar, grep, sed, and bash.

Simple Backup works by using a file that contains the folders to be backed up and a file that contains expressions to exclude certain folders/files.

Usage: backup.sh < backuplist > < excludelist >

Free to use at your own risk. The author cant be held responsible for any side effects
of using this software. Use at your own risk.